@zintrust/workers 0.1.29 → 0.1.30

package/dist/dashboard/workers-api.js

@@ -1,49 +1,109 @@
-import { ErrorFactory, Logger } from '@zintrust/core';
+import { Env, ErrorFactory, Logger } from '@zintrust/core';
 import { WorkerFactory } from '../WorkerFactory';
 import { WorkerMetrics as WorkerMetricsManager } from '../WorkerMetrics';
 const DEFAULT_PAGE_SIZE = 100;
 const MAX_PAGE_SIZE = 200;
+// Helper for timeout handling
+async function withTimeout(promise, timeoutMs, errorMsg) {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+        // eslint-disable-next-line no-restricted-syntax
+        timer = setTimeout(() => reject(new Error(errorMsg)), timeoutMs);
+    });
+    try {
+        const result = await Promise.race([promise, timeoutPromise]);
+        if (timer)
+            clearTimeout(timer);
+        return result;
+    }
+    catch (error) {
+        if (timer)
+            clearTimeout(timer);
+        throw error;
+    }
+}
+async function fetchPersistenceWithTimeout(page, limit, query) {
+    const driver = Env.get('WORKER_PERSISTENCE_DRIVER', 'memory');
+    try {
+        const result = await withTimeout(getWorkersFromPersistence(page, limit, query.driver, query), 5000, 'Persistence timeout');
+        return result;
+    }
+    catch (err) {
+        Logger.error(`[getWorkers] Persistence hung or failed (driver=${driver}), resetting connection state`, err);
+        if (typeof WorkerFactory.resetPersistence === 'function') {
+            await WorkerFactory.resetPersistence();
+        }
+        return {
+            workers: [],
+            total: 0,
+            drivers: ['memory'],
+            effectiveLimit: limit,
+            prePaginated: true,
+        };
+    }
+}
+async function fetchQueueDataSafe() {
+    const defaultData = {
+        driver: 'memory',
+        totalQueues: 0,
+        totalJobs: 0,
+        processingJobs: 0,
+        failedJobs: 0,
+    };
+    try {
+        return await withTimeout(getQueueData(), 3000, 'Queue data timeout');
+    }
+    catch (err) {
+        Logger.warn('[getWorkers] Queue data fetch failed or timed out', err);
+        return defaultData;
+    }
+}
+async function enrichWithMetricsSafe(workers) {
+    try {
+        return await withTimeout(enrichWithMetrics(workers), 5000, 'Metrics timeout');
+    }
+    catch (err) {
+        Logger.warn('[getWorkers] Metrics fetch failed or timed out', err);
+        // Reset metrics connection to avoid hanging next request
+        // We use fire-and-forget here because the request is already delayed/timed-out
+        // and we want to ensure the NEXT request has a clean slate (redisClient=null)
+        WorkerMetricsManager.shutdown().catch((e) => Logger.error('Failed to reset metrics connection', e));
+        return workers;
+    }
+}
 export async function getWorkers(query) {
+    const start = Date.now();
+    Logger.debug('[getWorkers] Start', query);
     const page = Math.max(1, query.page || 1);
     const limit = Math.min(MAX_PAGE_SIZE, Math.max(1, query.limit || DEFAULT_PAGE_SIZE));
     const offset = (page - 1) * limit;
     // Get workers from persistence based on configuration
-    const persistence = await getWorkersFromPersistence(page, limit, query.driver);
-    // Apply filters
+    const persistenceStart = Date.now();
+    const persistence = await fetchPersistenceWithTimeout(page, limit, query);
+    Logger.debug('[getWorkers] Persistence took ' + (Date.now() - persistenceStart) + 'ms', {
+        count: persistence.workers.length,
+        total: persistence.total,
+    });
+    // Apply filters/search/sorting
     let filteredWorkers = applyFilters(persistence.workers, query);
-    // Apply search
     if (query.search) {
         filteredWorkers = applySearch(filteredWorkers, query.search);
     }
-    // Apply sorting
     filteredWorkers = applySorting(filteredWorkers, query.sortBy, query.sortOrder);
     // Get queue data
-    const queueData = await getQueueData();
+    const queueStart = Date.now();
+    const queueData = await fetchQueueDataSafe();
+    Logger.debug('[getWorkers] Queue data took ' + (Date.now() - queueStart) + 'ms');
     // Apply pagination
     const paginatedWorkers = persistence.prePaginated
         ? filteredWorkers
         : filteredWorkers.slice(offset, offset + persistence.effectiveLimit);
-    const workersWithMetrics = await enrichWithMetrics(paginatedWorkers);
-    // Include details if requested
-    if (query.includeDetails) {
-        const enrichedWorkers = await enrichWithDetails(workersWithMetrics);
-        return {
-            workers: enrichedWorkers,
-            queueData,
-            pagination: {
-                page,
-                limit: persistence.effectiveLimit,
-                total: persistence.prePaginated ? persistence.total : filteredWorkers.length,
-                totalPages: Math.ceil((persistence.prePaginated ? persistence.total : filteredWorkers.length) /
-                    persistence.effectiveLimit),
-                hasNext: offset + persistence.effectiveLimit <
-                    (persistence.prePaginated ? persistence.total : filteredWorkers.length),
-                hasPrev: page > 1,
-            },
-            drivers: persistence.drivers,
-        };
-    }
-    return {
+    // Enrich with metrics
+    const metricsStart = Date.now();
+    const workersWithMetrics = await enrichWithMetricsSafe(paginatedWorkers);
+    Logger.debug('[getWorkers] Metrics took ' + (Date.now() - metricsStart) + 'ms');
+    // Prepare result
+    const result = {
         workers: workersWithMetrics,
         queueData,
         pagination: {
@@ -58,22 +118,35 @@ export async function getWorkers(query) {
         },
         drivers: persistence.drivers,
     };
+    // Include details if requested
+    if (query.includeDetails) {
+        const detailsStart = Date.now();
+        try {
+            result.workers = await enrichWithDetails(result.workers);
+        }
+        catch (err) {
+            Logger.warn('[getWorkers] Details fetch failed', err);
+        }
+        Logger.debug('[getWorkers] Details took ' + (Date.now() - detailsStart) + 'ms');
+    }
+    Logger.debug('[getWorkers] Total took ' + (Date.now() - start) + 'ms');
+    return result;
 }
-async function getWorkersFromPersistence(page, limit, driverFilter) {
+async function getWorkersFromPersistence(page, limit, driverFilter, query) {
     const offset = (page - 1) * limit;
-    const persistenceDriver = process.env['WORKER_PERSISTENCE_DRIVER'] ?? 'memory';
+    const persistenceDriver = Env.get('WORKER_PERSISTENCE_DRIVER', 'memory');
     const isMixedPersistence = persistenceDriver === 'database' || persistenceDriver === 'db';
     if (driverFilter) {
-        return getWorkersByDriverFilter(driverFilter, offset, limit);
+        return getWorkersByDriverFilter(driverFilter, offset, limit, query);
     }
     if (isMixedPersistence) {
-        return getWorkersFromMixedPersistence(offset, limit);
+        return getWorkersFromMixedPersistence(offset, limit, query);
     }
-    return getWorkersFromSinglePersistence(persistenceDriver, offset, limit);
+    return getWorkersFromSinglePersistence(persistenceDriver, offset, limit, query);
 }
-async function getWorkersByDriverFilter(driverFilter, offset, limit) {
+async function getWorkersByDriverFilter(driverFilter, offset, limit, query) {
     try {
-        const driverRecords = await WorkerFactory.listPersistedRecords({ driver: driverFilter }, { offset, limit });
+        const driverRecords = await WorkerFactory.listPersistedRecords({ driver: driverFilter }, { offset, limit, includeInactive: query.includeInactive });
         const workers = transformToWorkerData(driverRecords, driverFilter);
         return {
             workers,
@@ -94,10 +167,26 @@ async function getWorkersByDriverFilter(driverFilter, offset, limit) {
         };
     }
 }
-async function getWorkersFromMixedPersistence(offset, limit) {
+async function getWorkersFromMixedPersistence(offset, limit, query) {
+    const includeInactive = query.includeInactive;
+    let dbRecords = [];
+    let redisRecords = [];
+    try {
+        dbRecords = await WorkerFactory.listPersistedRecords({ driver: 'database', connection: 'mysql' }, { offset, limit, includeInactive });
+    }
+    catch (error) {
+        // In some environments (like Cloudflare), database access might not be available.
+        // We log this as debug instead of error to avoid noise.
+        Logger.debug('Failed to fetch from database persistence:', error);
+    }
+    try {
+        redisRecords = await WorkerFactory.listPersistedRecords({ driver: 'redis' }, { offset, limit, includeInactive });
+    }
+    catch (error) {
+        // Similarly for Redis if direct connection is not available.
+        Logger.debug('Failed to fetch from redis persistence:', error);
+    }
     try {
-        const dbRecords = await WorkerFactory.listPersistedRecords({ driver: 'database' }, { offset, limit });
-        const redisRecords = await WorkerFactory.listPersistedRecords({ driver: 'redis' }, { offset, limit });
         const workers = [
             ...transformToWorkerData(dbRecords, 'database'),
             ...transformToWorkerData(redisRecords, 'redis'),
@@ -113,7 +202,7 @@ async function getWorkersFromMixedPersistence(offset, limit) {
         };
     }
     catch (error) {
-        Logger.error('Error fetching workers from mixed persistence:', error);
+        Logger.error('Error transforming workers from mixed persistence:', error);
         return {
             workers: [],
             total: 0,
@@ -123,10 +212,10 @@ async function getWorkersFromMixedPersistence(offset, limit) {
         };
     }
 }
-async function getWorkersFromSinglePersistence(persistenceDriver, offset, limit) {
+async function getWorkersFromSinglePersistence(persistenceDriver, offset, limit, query) {
     try {
         const normalizedDriver = normalizeDriver(persistenceDriver);
-        const driverRecords = await WorkerFactory.listPersistedRecords({ driver: normalizedDriver }, { offset, limit });
+        const driverRecords = await WorkerFactory.listPersistedRecords({ driver: normalizedDriver }, { offset, limit, includeInactive: query.includeInactive });
         const workers = transformToWorkerData(driverRecords, normalizedDriver);
         return {
             workers,
@@ -181,6 +270,7 @@ const buildWorkerFromRecord = (record, driver) => {
         version: record.version ?? '1.0.0',
         autoStart: record.autoStart,
         lastError: record.lastError,
+        activeStatus: record.activeStatus ?? true,
     };
     return buildWorkerFromRaw(rawData, driver);
 };
@@ -197,6 +287,7 @@ const buildWorkerFromRaw = (workerData, driver) => {
         avgTime: workerData.avgTime || 0,
         memory: workerData.memory || 0,
         autoStart: workerData.autoStart || false,
+        activeStatus: workerData.activeStatus ?? true,
         details: workerData.details || {
             configuration: {},
             health: {},
@@ -306,7 +397,7 @@ function applySorting(workers, sortBy, sortOrder = 'asc') {
     });
 }
 async function getQueueData() {
-    const queueDriver = process.env.QUEUE_DRIVER || 'redis';
+    const queueDriver = Env.get('QUEUE_DRIVER', 'redis');
     try {
         // Get queue statistics based on QUEUE_DRIVER
         switch (queueDriver) {
@@ -512,7 +603,8 @@ function buildWorkerConfiguration(worker, persisted) {
             queueName: worker.queueName,
             concurrency: null,
             region: null,
-            processorPath: null,
+            processorSpec: null,
+            activeStatus: null,
             version: worker.version,
             features: null,
             infrastructure: null,
@@ -523,7 +615,8 @@ function buildWorkerConfiguration(worker, persisted) {
         queueName: persisted.queueName ?? worker.queueName,
         concurrency: persisted.concurrency ?? null,
         region: persisted.region ?? null,
-        processorPath: persisted.processorPath ?? null,
+        processorSpec: persisted.processorSpec ?? null,
+        activeStatus: persisted.activeStatus ?? true,
         version: persisted.version ?? worker.version,
         features: persisted.features ?? null,
         infrastructure: persisted.infrastructure ?? null,

package/dist/http/WorkerApiController.js

@@ -73,6 +73,7 @@ export const listWorkers = async (req, res) => {
             ]),
             search: getQueryParam(query, 'search'),
             includeDetails: getBooleanParam(query, 'includeDetails', false),
+            includeInactive: getBooleanParam(query, 'includeInactive', false),
         };
         const result = await getWorkers(queryParams);
         res.json(result);

package/dist/http/WorkerController.js

@@ -3,9 +3,8 @@
  * Worker Controller
  * HTTP handlers for worker management API
  */
-import { Logger, getValidatedBody } from '@zintrust/core';
+import { Env, Logger, getValidatedBody } from '@zintrust/core';
 import { CanaryController } from '../CanaryController';
-import { getWorkers } from '../dashboard/workers-api';
 import { HealthMonitor } from '../HealthMonitor';
 import { getParam } from '../helper';
 import { SLAMonitor } from '../index';
@@ -14,6 +13,7 @@ import { WorkerFactory } from '../WorkerFactory';
 import { WorkerRegistry } from '../WorkerRegistry';
 import { WorkerShutdown } from '../WorkerShutdown';
 import { WorkerVersioning } from '../WorkerVersioning';
+import { WorkerMonitoringService } from './WorkerMonitoringService';
 /**
  * Helper to get request body
  */
@@ -50,12 +50,12 @@ async function create(req, res) {
         }
         const rawProcessor = body.processor;
         let processor;
-        let processorPath;
+        let processorSpec;
         if (typeof rawProcessor === 'string') {
-            processorPath = rawProcessor;
-            const resolved = await WorkerFactory.resolveProcessorPath(rawProcessor);
+            processorSpec = rawProcessor;
+            const resolved = await WorkerFactory.resolveProcessorSpec(rawProcessor);
             if (!resolved) {
-                res.setStatus(400).json({ error: 'Processor path could not be resolved' });
+                res.setStatus(400).json({ error: 'Processor spec could not be resolved' });
                 return;
             }
             processor = resolved;
@@ -70,7 +70,7 @@ async function create(req, res) {
         const config = {
             ...body,
             processor,
-            processorPath,
+            processorSpec,
         };
         await WorkerFactory.create(config);
         res.json({
@@ -98,6 +98,9 @@ async function start(req, res) {
             return;
         }
         const persistenceOverride = resolvePersistenceOverride(req);
+        const isActive = await ensureActiveWorker(name, persistenceOverride, res);
+        if (!isActive)
+            return;
         const registered = WorkerRegistry.list().includes(name);
         if (!registered) {
             await WorkerFactory.startFromPersisted(name, persistenceOverride);
@@ -121,6 +124,9 @@ async function stop(req, res) {
     try {
         const name = getParam(req, 'name');
         const persistenceOverride = resolvePersistenceOverride(req);
+        const isActive = await ensureActiveWorker(name, persistenceOverride, res);
+        if (!isActive)
+            return;
         await WorkerFactory.stop(name, persistenceOverride);
         res.json({ ok: true, message: `Worker ${name} stopped` });
     }
@@ -138,6 +144,9 @@ async function restart(req, res) {
     try {
         const name = getParam(req, 'name');
         const persistenceOverride = resolvePersistenceOverride(req);
+        const isActive = await ensureActiveWorker(name, persistenceOverride, res);
+        if (!isActive)
+            return;
         await WorkerFactory.restart(name, persistenceOverride);
         res.json({ ok: true, message: `Worker ${name} restarted` });
     }
@@ -170,6 +179,9 @@ async function setAutoStart(req, res) {
             enabled = ['true', '1', 'yes', 'on'].includes(enabledStr.toLowerCase());
         }
         const persistenceOverride = resolvePersistenceOverride(req);
+        const isActive = await ensureActiveWorker(name, persistenceOverride, res);
+        if (!isActive)
+            return;
         await WorkerFactory.setAutoStart(name, enabled, persistenceOverride);
         res.json({ ok: true, message: `Worker ${name} autoStart set to ${enabled}` });
     }
@@ -187,6 +199,9 @@ async function pause(req, res) {
     try {
         const name = getParam(req, 'name');
         const persistenceOverride = resolvePersistenceOverride(req);
+        const isActive = await ensureActiveWorker(name, persistenceOverride, res);
+        if (!isActive)
+            return;
         await WorkerFactory.pause(name, persistenceOverride);
         res.json({ ok: true, message: `Worker ${name} paused` });
     }
@@ -204,6 +219,9 @@ async function resume(req, res) {
     try {
         const name = getParam(req, 'name');
         const persistenceOverride = resolvePersistenceOverride(req);
+        const isActive = await ensureActiveWorker(name, persistenceOverride, res);
+        if (!isActive)
+            return;
         await WorkerFactory.resume(name, persistenceOverride);
         res.json({ ok: true, message: `Worker ${name} resumed` });
     }
@@ -270,6 +288,21 @@ const resolvePersistenceOverride = (req) => {
     }
     return undefined;
 };
+const ensureActiveWorker = async (name, persistenceOverride, res) => {
+    if (!name)
+        return false;
+    const instance = WorkerFactory.get(name);
+    if (instance?.config?.activeStatus === false) {
+        res.setStatus(410).json({ error: 'Worker is inactive', code: 'WORKER_INACTIVE' });
+        return false;
+    }
+    const persisted = await WorkerFactory.getPersisted(name, persistenceOverride);
+    if (persisted?.activeStatus === false) {
+        res.setStatus(410).json({ error: 'Worker is inactive', code: 'WORKER_INACTIVE' });
+        return false;
+    }
+    return true;
+};
 /**
  * Get a specific worker instance
  * @param req.params.name - Worker name
@@ -314,8 +347,13 @@ async function update(req, res) {
             res.setStatus(404).json({ error: `Worker ${name} not found` });
             return;
         }
-        // Validate and merge updates (excluding immutable fields)
+        // Remove immutable fields and prepare updates
         const { name: _name, driver: _driver, ...updateData } = reqData; // Remove immutable fields
+        const processorValid = await validateProcessorSpecIfNeeded(updateData);
+        if (!processorValid) {
+            res.setStatus(400).json({ error: 'Processor spec could not be resolved' });
+            return;
+        }
         // Note: driver is determined by persistence configuration, not stored in worker record
         const updatedRecord = {
             ...currentRecord,
@@ -324,34 +362,9 @@ async function update(req, res) {
             updatedAt: new Date(),
         };
         updatedRecord.infrastructure.persistence.driver = driver;
-        // Update persistence store with the complete updated record
-        try {
-            // Persist merged record via WorkerFactory API
-            await WorkerFactory.update(name, updatedRecord, persistenceOverride);
-            Logger.info(`Worker ${name} persistence updated with fields:`, Object.keys(updateData));
-        }
-        catch (persistError) {
-            Logger.warn(`Failed to persist some updates for ${name}`, persistError);
-            // Continue with restart even if persistence update partially fails
-        }
-        // If worker is currently running, restart it to apply new configuration changes
-        // This ensures new concurrency, queue settings, and other config take effect
+        await persistUpdatedRecord(name, updatedRecord, persistenceOverride, updateData);
         const currentInstance = WorkerFactory.get(name);
-        let restartError;
-        if (currentInstance && currentInstance.status === 'running') {
-            try {
-                Logger.info(`Restarting worker ${name} to apply configuration changes`);
-                await WorkerFactory.restart(name, persistenceOverride);
-            }
-            catch (error) {
-                restartError = error.message;
-                Logger.warn(`Failed to restart worker ${name} after update`, error);
-                // Don't fail the update, but warn about restart failure
-            }
-        }
-        else {
-            Logger.info(`Worker ${name} is not running (status: ${currentInstance?.status || 'not found'}), skipping restart`);
-        }
+        const restartError = await restartIfNeeded(name, currentInstance, updatedRecord, currentRecord, persistenceOverride);
         // Worker configuration updated in persistence and memory
         Logger.info(`Worker configuration updated: ${name}`, {
             updatedFields: Object.keys(updateData),
@@ -371,6 +384,43 @@ async function update(req, res) {
         res.setStatus(500).json({ error: error.message });
     }
 }
+// Helpers extracted from update() to reduce complexity
+async function validateProcessorSpecIfNeeded(updateData) {
+    if (typeof updateData['processorSpec'] === 'string') {
+        const resolved = await WorkerFactory.resolveProcessorSpec(updateData['processorSpec']);
+        return Boolean(resolved);
+    }
+    return true;
+}
+async function persistUpdatedRecord(name, updatedRecord, persistenceOverride, updateData) {
+    try {
+        await WorkerFactory.update(name, updatedRecord, persistenceOverride);
+        Logger.info(`Worker ${name} persistence updated with fields:`, Object.keys(updateData));
+    }
+    catch (persistError) {
+        Logger.warn(`Failed to persist some updates for ${name}`, persistError);
+        // Continue execution even if persistence update partially fails
+    }
+}
+async function restartIfNeeded(name, currentInstance, updatedRecord, currentRecord, persistenceOverride) {
+    if (!currentInstance ||
+        currentInstance.status !== 'running' ||
+        updatedRecord.activeStatus === false ||
+        currentRecord.activeStatus === false) {
+        Logger.info(`Worker ${name} is not running (status: ${currentInstance?.status || 'not found'}), skipping restart`);
+        return undefined;
+    }
+    try {
+        Logger.info(`Restarting worker ${name} to apply configuration changes`);
+        await WorkerFactory.restart(name, persistenceOverride);
+        return undefined;
+    }
+    catch (err) {
+        const restartError = err.message;
+        Logger.warn(`Failed to restart worker ${name} after update`, err);
+        return restartError;
+    }
+}
 /**
  * Get worker status
  * @param req.params.name - Worker name
@@ -536,7 +586,7 @@ async function getSlaStatus(req, res) {
     catch (error) {
         Logger.error('WorkerController.getSlaStatus failed', error);
         if (error.message.includes('SLA config not found')) {
-            res.setStatus(404).json({ error: 'SLA config not found for worker' });
+            res.setStatus(400).json({ error: 'SLA config not found for worker' });
         }
         else {
             res.setStatus(500).json({ error: error.message });
@@ -1116,61 +1166,59 @@ async function monitoringSummary(_req, res) {
         res.setStatus(500).json({ error: error.message });
     }
 }
+const SSE_HEARTBEAT_INTERVAL = Env.SSE_HEARTBEAT_INTERVAL;
 /**
  * SSE endpoint: stream worker and monitoring events
  * GET /api/workers/events
  */
 const eventsStream = async (_req, res) => {
-    const raw = res.getRaw();
-    raw.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache, no-transform',
-        Connection: 'keep-alive',
-        'X-Accel-Buffering': 'no',
-    });
-    let closed = false;
-    const send = async (payload) => {
-        try {
-            const data = JSON.stringify(payload);
-            raw.write(`data: ${data}\n\n`);
-        }
-        catch (err) {
-            Logger.error('WorkerController.eventsStream failed', err);
-            // ignore serialization errors
-        }
-    };
-    // Send initial hello
-    await send({ type: 'hello', ts: new Date().toISOString() });
-    // Periodic snapshot sender
-    const intervalMs = 5000;
-    const interval = setInterval(async () => {
-        try {
-            const monitoring = await HealthMonitor.getSummary();
-            // include full workers listing with metrics/pagination to allow clients to patch the UI
-            const workersPayload = await getWorkers({ page: 1, limit: 200 });
-            await send({
-                type: 'snapshot',
-                ts: new Date().toISOString(),
-                monitoring,
-                workers: workersPayload,
-            });
-        }
-        catch (err) {
-            // send error event
-            await send({ type: 'error', ts: new Date().toISOString(), message: err.message });
+    try {
+        const raw = res.getRaw();
+        raw.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        let closed = false;
+        const send = (payload) => {
+            if (closed)
+                return;
+            try {
+                const data = JSON.stringify(payload);
+                raw.write(`data: ${data}\n\n`);
+            }
+            catch (err) {
+                Logger.error('WorkerController.eventsStream serialization failed', err);
+            }
+        };
+        // Send hello immediately
+        send({ type: 'hello', ts: new Date().toISOString() });
+        // Defined subscription callback
+        const onSnapshot = (data) => {
+            send(data);
+        };
+        // Subscribe to centralized service
+        WorkerMonitoringService.subscribe(onSnapshot);
+        // Heartbeat to keep connection alive
+        const hb = setInterval(() => {
+            if (!closed)
+                raw.write(': ping\n\n');
+        }, SSE_HEARTBEAT_INTERVAL);
+        // Clean up when client disconnects
+        raw.on('close', () => {
+            closed = true;
+            clearInterval(hb);
+            WorkerMonitoringService.unsubscribe(onSnapshot);
+        });
+    }
+    catch (error) {
+        Logger.error('WorkerController.eventsStream failed', error);
+        const raw = res.getRaw && typeof res.getRaw === 'function' ? res.getRaw() : null;
+        if (!raw?.headersSent) {
+            res.setStatus(500).json({ error: error.message });
         }
-    }, intervalMs);
-    // Heartbeat to keep connection alive
-    const hb = setInterval(() => {
-        if (!closed)
-            raw.write(': ping\n\n');
-    }, 15000);
-    // Clean up when client disconnects
-    raw.on('close', () => {
-        closed = true;
-        clearInterval(interval);
-        clearInterval(hb);
-    });
+    }
 };
 /**
  * Builders that group related handlers to keep the create() method small.

package/dist/http/WorkerMonitoringService.d.ts

@@ -0,0 +1,11 @@
+type SnapshotData = {
+    type: string;
+    ts: string;
+    monitoring: unknown;
+    workers: unknown;
+};
+export declare const WorkerMonitoringService: Readonly<{
+    subscribe(callback: (data: SnapshotData) => void): void;
+    unsubscribe(callback: (data: SnapshotData) => void): void;
+}>;
+export {};