devchain-cli 0.24.2 → 0.26.0

package/dist/server/modules/sessions/services/sessions-message-pool.service.js

@@ -14,7 +14,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionsMessagePoolService = exports.FORCE_ELIGIBLE_DELAY_MS = exports.HUMAN_DRAFT_IDLE_GRACE_MS = exports.FAILURE_NOTICE_SOURCE = void 0;
 const common_1 = require("@nestjs/common");
-const event_emitter_1 = require("@nestjs/event-emitter");
+const on_catalog_event_1 = require("../../events/catalog/on-catalog-event");
 const crypto_1 = require("crypto");
 const sessions_service_1 = require("./sessions.service");
 const session_coordinator_service_1 = require("./session-coordinator.service");
@@ -25,6 +25,7 @@ const settings_service_1 = require("../../settings/services/settings.service");
 const storage_interface_1 = require("../../storage/interfaces/storage.interface");
 const logger_1 = require("../../../common/logging/logger");
 const terminal_io_service_1 = require("../../terminal/services/terminal-io/terminal-io.service");
+const delivery_1 = require("../../terminal/services/terminal-io/delivery");
 const provider_adapter_factory_1 = require("../../providers/adapters/provider-adapter.factory");
 const message_pool_types_1 = require("./message-pool.types");
 const session_human_prompt_state_changed_1 = require("../../events/catalog/session.human-prompt-state-changed");
@@ -42,6 +43,9 @@ function deferredClaimCancellationResult(claim, discardedCount) {
     const reason = claim?.state.phase === 'preparing' ? claim.state.cancellationReason : undefined;
     return reason ? { success: false, discardedCount, reason } : null;
 }
+function deliveryFailureCode(error, fallback) {
+    return error instanceof delivery_1.ShellForegroundError ? 'shell_foreground' : fallback;
+}
 const DEFAULT_CONFIG = {
     enabled: true,
     delayMs: 10000,
@@ -110,10 +114,6 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             return this.config;
         }
     }
-    reloadConfig() {
-        this.config = this.loadConfigFromSettings();
-        logger.info({ config: this.config }, 'Message pool configuration reloaded');
-    }
     configure(config) {
         this.config = { ...this.config, ...config };
         logger.info({ config: this.config }, 'Message pool configuration updated');
@@ -144,25 +144,10 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         const remaining = newConfig.maxWaitMs - elapsed;
         if (remaining <= 0) {
             logger.debug({ agentId, projectId: pool.projectId, elapsed, maxWaitMs: newConfig.maxWaitMs }, 'Max wait already exceeded after config reload, scheduling immediate flush');
-            setTimeout(() => {
-                this.flushNow(agentId).catch((err) => {
-                    logger.error({
-                        agentId,
-                        error: this.disclosedLogError((0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(pool.messages), err),
-                    }, 'Immediate flush after config reload failed');
-                });
-            }, 0);
+            this.createPoolFlushTimer(agentId, pool, 0, 'Immediate flush after config reload failed');
             return;
         }
-        pool.maxWaitTimer = setTimeout(() => {
-            logger.debug({ agentId, projectId: pool.projectId }, 'Max wait timer triggered (after config reload)');
-            this.flushNow(agentId).catch((err) => {
-                logger.error({
-                    agentId,
-                    error: this.disclosedLogError((0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(pool.messages), err),
-                }, 'Max wait flush failed');
-            });
-        }, remaining);
+        pool.maxWaitTimer = this.createPoolFlushTimer(agentId, pool, remaining, 'Max wait flush failed', 'Max wait timer triggered (after config reload)');
     }
     async enqueue(agentId, text, options = {}) {
         const { source = 'unknown', submitKeys = ['Enter'], preKeys, preDelayMs, senderAgentId, clientMessageId, failureDisclosure = 'legacy', } = options;
@@ -170,120 +155,58 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         const logEntryId = (0, crypto_1.randomUUID)();
         const timestamp = Date.now();
         const deliveryMode = this.resolveDeliveryMode(options);
-        if (options.deferWhileHumanTyping || options.humanPromptSubmit || deliveryMode === 'on_idle') {
-            return this.enqueueSerialized({
-                agentId,
-                text,
-                source,
-                submitKeys,
-                preKeys,
-                preDelayMs,
-                senderAgentId,
-                clientMessageId,
-                failureDisclosure,
-                projectId,
-                agentName,
-                logEntryId,
-                timestamp,
-                deliveryMode,
-                deferWhileHumanTyping: options.deferWhileHumanTyping === true,
-                humanPromptSubmit: options.humanPromptSubmit === true,
-                outsideText: options.outsideText === true,
-            });
+        const input = {
+            agentId,
+            text,
+            source,
+            submitKeys,
+            preKeys,
+            preDelayMs,
+            senderAgentId,
+            clientMessageId,
+            failureDisclosure,
+            projectId,
+            agentName,
+            logEntryId,
+            timestamp,
+            deliveryMode,
+            deferWhileHumanTyping: options.deferWhileHumanTyping === true,
+            humanPromptSubmit: options.humanPromptSubmit === true,
+            outsideText: options.outsideText === true,
+        };
+        if (options.commandGuard) {
+            return this.enqueueCommand({ ...input, deliveryMode: 'immediate', humanPromptSubmit: false }, options.commandGuard);
+        }
+        if (input.deferWhileHumanTyping || input.humanPromptSubmit || deliveryMode === 'on_idle') {
+            return this.enqueueSerialized(input);
         }
         const projectConfig = this.getConfigForProject(projectId, failureDisclosure);
         const immediateDelivery = deliveryMode === 'immediate';
         if (immediateDelivery || !projectConfig.enabled) {
             const reason = immediateDelivery ? 'delivery mode' : 'pooling disabled';
             logger.debug({ agentId, projectId, source, reason }, 'Bypassing pool, delivering immediately');
-            const logEntry = {
-                id: logEntryId,
-                timestamp,
-                projectId,
-                agentId,
-                agentName,
-                text,
-                source,
-                senderAgentId,
-                clientMessageId,
-                status: 'queued',
-                immediate: true,
-            };
-            if (clientMessageId) {
-                const existing = this.messageLog.findByClientMessageId(clientMessageId, agentId, source);
-                if (existing) {
-                    logger.debug({ agentId, source, clientMessageId, logEntryId: existing.id }, 'Duplicate clientMessageId — returning existing entry, skipping re-delivery');
-                    return { status: existing.status, logEntryId: existing.id };
-                }
+            const duplicate = this.findDuplicate(input);
+            if (duplicate) {
+                logger.debug({ agentId, source, clientMessageId, logEntryId: duplicate.logEntryId }, 'Duplicate clientMessageId — returning existing entry, skipping re-delivery');
+                return duplicate;
             }
-            this.messageLog.addEntry(logEntry);
-            this.activityStream.broadcastEnqueued(logEntry);
-            this.broadcastPoolsUpdate();
+            this.recordEnqueued(this.createLogEntry(input, true));
             try {
-                const { nonce: deliveredNonce, unconfirmed, skipped, retryCount, } = await this.deliverMessage(agentId, text, submitKeys, {
+                const delivery = await this.deliverMessage(agentId, text, submitKeys, {
                     skipConfirmation: immediateDelivery,
                     preKeys,
                     preDelayMs,
-                    outsideText: options.outsideText === true,
+                    outsideText: input.outsideText,
                 });
-                const status = unconfirmed ? 'unconfirmed' : 'delivered';
-                const deliveredAt = Date.now();
-                this.messageLog.update(logEntryId, {
-                    status,
-                    deliveredAt,
-                    nonce: skipped ? undefined : deliveredNonce,
-                    confirmedAt: skipped || unconfirmed ? undefined : deliveredAt,
-                    retryCount,
-                    failureCode: unconfirmed ? 'paste_not_confirmed' : undefined,
-                });
-                const updatedEntry = this.messageLog.getById(logEntryId);
-                if (updatedEntry) {
-                    if (unconfirmed) {
-                        this.activityStream.broadcastUnconfirmed(logEntryId, [updatedEntry]);
-                    }
-                    else {
-                        this.activityStream.broadcastDelivered(logEntryId, [updatedEntry]);
-                    }
-                }
-                return { status, logEntryId };
+                return this.recordImmediateDelivered(logEntryId, delivery);
             }
             catch (error) {
-                const errorMsg = error instanceof Error ? error.message : String(error);
-                const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(failureDisclosure, errorMsg, 'tmux_error');
-                logger.error({ agentId, source, error: failure.error }, 'Immediate delivery failed');
-                this.messageLog.update(logEntryId, {
-                    status: 'failed',
-                    error: failure.error,
-                    failureCode: failure.failureCode,
-                });
-                const failedEntry = this.messageLog.getById(logEntryId);
-                if (failedEntry) {
-                    this.activityStream.broadcastFailed(failedEntry);
-                }
-                return { status: 'failed', error: failure.error, logEntryId };
+                return this.recordImmediateFailed(input, error);
             }
         }
         let pool = this.pools.get(agentId);
         if (!pool) {
-            pool = {
-                messages: [],
-                timer: null,
-                maxWaitTimer: null,
-                firstEnqueueTime: Date.now(),
-                config: projectConfig,
-                projectId,
-            };
-            this.pools.set(agentId, pool);
-            const scheduledPool = pool;
-            pool.maxWaitTimer = setTimeout(() => {
-                logger.debug({ agentId, projectId }, 'Max wait timer triggered');
-                this.flushNow(agentId).catch((err) => {
-                    logger.error({
-                        agentId,
-                        error: this.disclosedLogError((0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(scheduledPool.messages), err),
-                    }, 'Max wait flush failed');
-                });
-            }, projectConfig.maxWaitMs);
+            pool = this.createAgentPool(agentId, projectId, projectConfig, 'Max wait timer triggered');
             logger.debug({ agentId, projectId, config: projectConfig }, 'Created new pool with project-specific config');
         }
         else {
@@ -305,29 +228,12 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
                 }
             }
         }
-        const logEntry = {
-            id: logEntryId,
-            timestamp,
-            projectId,
-            agentId,
-            agentName,
-            text,
-            source,
-            senderAgentId,
-            clientMessageId,
-            status: 'queued',
-            immediate: false,
-        };
-        if (clientMessageId) {
-            const existing = this.messageLog.findByClientMessageId(clientMessageId, agentId, source);
-            if (existing) {
-                logger.debug({ agentId, source, clientMessageId, logEntryId: existing.id }, 'Duplicate clientMessageId — returning existing entry, skipping re-enqueue');
-                return { status: existing.status, logEntryId: existing.id };
-            }
+        const duplicate = this.findDuplicate(input);
+        if (duplicate) {
+            logger.debug({ agentId, source, clientMessageId, logEntryId: duplicate.logEntryId }, 'Duplicate clientMessageId — returning existing entry, skipping re-enqueue');
+            return duplicate;
         }
-        this.messageLog.addEntry(logEntry);
-        this.activityStream.broadcastEnqueued(logEntry);
-        this.broadcastPoolsUpdate();
+        this.recordEnqueued(this.createLogEntry(input, false));
         const message = {
             text,
             source,
@@ -337,7 +243,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             logEntryId,
             clientMessageId,
             failureDisclosure,
-            outsideText: options.outsideText === true,
+            outsideText: input.outsideText,
         };
         pool.messages.push(message);
         logger.debug({ agentId, projectId, source, poolSize: pool.messages.length }, 'Message enqueued to pool');
@@ -349,21 +255,36 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             }
             return { status: flushResult.outcome === 'unconfirmed' ? 'unconfirmed' : 'delivered' };
         }
-        if (pool.timer) {
-            clearTimeout(pool.timer);
-        }
-        const scheduledPool = pool;
-        pool.timer = setTimeout(() => {
-            logger.debug({ agentId, projectId }, 'Debounce timer triggered');
-            this.flushNow(agentId).catch((err) => {
-                logger.error({
-                    agentId,
-                    error: this.disclosedLogError((0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(scheduledPool.messages), err),
-                }, 'Debounce flush failed');
-            });
-        }, pool.config.delayMs);
+        this.schedulePoolDebounce(agentId, pool, 'Debounce timer triggered');
         return { status: 'queued', poolSize: pool.messages.length, logEntryId };
     }
+    async enqueueCommand(input, commandGuard) {
+        return this.coordinator.withAgentLock(input.agentId, async () => {
+            const activeSession = this.sessions.getActiveSessionForAgent(input.agentId);
+            let error;
+            if (!activeSession || activeSession.id !== commandGuard.sessionId) {
+                error = 'SESSION_CHANGED';
+            }
+            else if (activeSession.activityState !== 'idle' ||
+                this.deferredLanes.get(input.agentId)?.activeClaim) {
+                error = 'AGENT_BUSY';
+            }
+            else if (activeSession.tmuxSessionId &&
+                this.humanPromptState.getState(activeSession.tmuxSessionId).phase !== 'inactive') {
+                error = 'HUMAN_TYPING';
+            }
+            if (!error) {
+                const duplicate = this.findDuplicate(input);
+                if (duplicate)
+                    return duplicate;
+            }
+            const logEntry = this.createLogEntry(input, true);
+            this.recordEnqueued(logEntry);
+            return error
+                ? this.recordImmediateFailed(input, error)
+                : this.deliverImmediateUnderAgentLock(input, logEntry);
+        });
+    }
     async enqueueSerialized(input) {
         while (true) {
             const step = await this.coordinator.withAgentLock(input.agentId, async () => {
@@ -422,9 +343,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         }
         if (input.humanPromptSubmit || input.deliveryMode === 'immediate' || !projectConfig.enabled) {
             const logEntry = this.createLogEntry(input, true);
-            this.messageLog.addEntry(logEntry);
-            this.activityStream.broadcastEnqueued(logEntry);
-            this.broadcastPoolsUpdate();
+            this.recordEnqueued(logEntry);
             return this.deliverImmediateUnderAgentLock(input, logEntry);
         }
         return this.enqueueProtectedPoolUnderAgentLock(input, projectConfig);
@@ -435,6 +354,45 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         const existing = this.messageLog.findByClientMessageId(input.clientMessageId, input.agentId, input.source);
         return existing ? { status: existing.status, logEntryId: existing.id } : null;
     }
+    recordEnqueued(logEntry) {
+        this.messageLog.addEntry(logEntry);
+        this.activityStream.broadcastEnqueued(logEntry);
+        this.broadcastPoolsUpdate();
+    }
+    recordImmediateDelivered(logEntryId, delivery) {
+        const status = delivery.unconfirmed ? 'unconfirmed' : 'delivered';
+        const deliveredAt = Date.now();
+        this.messageLog.update(logEntryId, {
+            status,
+            deliveredAt,
+            nonce: delivery.skipped ? undefined : delivery.nonce,
+            confirmedAt: delivery.skipped || delivery.unconfirmed ? undefined : deliveredAt,
+            retryCount: delivery.retryCount,
+            failureCode: delivery.unconfirmed ? 'paste_not_confirmed' : undefined,
+        });
+        const updated = this.messageLog.getById(logEntryId);
+        if (updated) {
+            if (delivery.unconfirmed)
+                this.activityStream.broadcastUnconfirmed(logEntryId, [updated]);
+            else
+                this.activityStream.broadcastDelivered(logEntryId, [updated]);
+        }
+        return { status, logEntryId };
+    }
+    recordImmediateFailed(input, error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(input.failureDisclosure, errorMsg, deliveryFailureCode(error, 'tmux_error'));
+        logger.error({ agentId: input.agentId, source: input.source, error: failure.error }, 'Immediate delivery failed');
+        this.messageLog.update(input.logEntryId, {
+            status: 'failed',
+            error: failure.error,
+            failureCode: failure.failureCode,
+        });
+        const failed = this.messageLog.getById(input.logEntryId);
+        if (failed)
+            this.activityStream.broadcastFailed(failed);
+        return { status: 'failed', error: failure.error, logEntryId: input.logEntryId };
+    }
     createLogEntry(input, immediate) {
         return {
             id: input.logEntryId,
@@ -480,10 +438,8 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
                 this.resetPoolTimers(input.agentId, pool, projectConfig);
         }
         const logEntry = this.createLogEntry(input, false);
-        this.messageLog.addEntry(logEntry);
         pool.messages.push(this.createPooledMessage(input));
-        this.activityStream.broadcastEnqueued(logEntry);
-        this.broadcastPoolsUpdate();
+        this.recordEnqueued(logEntry);
         if (pool.messages.length >= pool.config.maxMessages) {
             const result = await this.flushPoolUnderAgentLock(input.agentId);
             if (!result.success)
@@ -537,12 +493,10 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             requiresProviderIdle: input.deliveryMode === 'on_idle',
             heldGeneration,
         });
-        this.messageLog.addEntry(logEntry);
         lane.messages.push(message);
         if (heldGeneration !== undefined)
             this.rebindLaneGeneration(lane, heldGeneration);
-        this.activityStream.broadcastEnqueued(logEntry);
-        this.broadcastPoolsUpdate();
+        this.recordEnqueued(logEntry);
         if (lane.requiredGeneration !== null) {
             this.ensureHumanQuietTimerUnderAgentLock(lane);
         }
@@ -560,7 +514,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         return ((this.pools.get(agentId)?.messages.length ?? 0) +
             (this.deferredLanes.get(agentId)?.messages.length ?? 0));
     }
-    createAgentPool(agentId, projectId, config) {
+    createAgentPool(agentId, projectId, config, triggerLog) {
         const pool = {
             messages: [],
             timer: null,
@@ -570,17 +524,25 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             projectId,
         };
         this.pools.set(agentId, pool);
-        pool.maxWaitTimer = setTimeout(() => {
-            void this.flushNow(agentId);
-        }, config.maxWaitMs);
+        pool.maxWaitTimer = this.createPoolFlushTimer(agentId, pool, config.maxWaitMs, 'Max wait flush failed', triggerLog);
         return pool;
     }
-    schedulePoolDebounce(agentId, pool) {
+    schedulePoolDebounce(agentId, pool, triggerLog) {
         if (pool.timer)
             clearTimeout(pool.timer);
-        pool.timer = setTimeout(() => {
-            void this.flushNow(agentId);
-        }, pool.config.delayMs);
+        pool.timer = this.createPoolFlushTimer(agentId, pool, pool.config.delayMs, 'Debounce flush failed', triggerLog);
+    }
+    createPoolFlushTimer(agentId, pool, delayMs, failureMessage, triggerLog) {
+        return setTimeout(() => {
+            if (triggerLog)
+                logger.debug({ agentId, projectId: pool.projectId }, triggerLog);
+            this.flushNow(agentId).catch((error) => {
+                logger.error({
+                    agentId,
+                    error: this.disclosedLogError((0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(pool.messages), error),
+                }, failureMessage);
+            });
+        }, delayMs);
     }
     async flushNow(agentId) {
         while (true) {
@@ -877,9 +839,6 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
     getMessageLog(options) {
         return this.messageLog.query(options);
     }
-    getLogStats() {
-        return this.messageLog.getStats();
-    }
     getMessageById(messageId) {
         return this.messageLog.getMessageById(messageId);
     }
@@ -1373,9 +1332,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             const cancellation = deferredClaimCancellationResult(claim, messages.length);
             if (cancellation)
                 return cancellation;
-            const failureCode = errorMsg.includes('send keys')
-                ? 'send_keys_failed'
-                : 'tmux_error';
+            const failureCode = deliveryFailureCode(error, errorMsg.includes('send keys') ? 'send_keys_failed' : 'tmux_error');
             const batchFailure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(failureDisclosure, errorMsg, failureCode);
             logger.error({ agentId, sessionId: target.sessionId, error: batchFailure.error }, 'Failed to deliver batch to exact agent session');
             for (const message of messages) {
@@ -1460,43 +1417,16 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
                 preDelayMs: input.preDelayMs,
                 outsideText: input.outsideText,
             });
-            const status = delivery.unconfirmed ? 'unconfirmed' : 'delivered';
-            const deliveredAt = Date.now();
-            this.messageLog.update(logEntry.id, {
-                status,
-                deliveredAt,
-                nonce: delivery.skipped ? undefined : delivery.nonce,
-                confirmedAt: delivery.skipped || delivery.unconfirmed ? undefined : deliveredAt,
-                retryCount: delivery.retryCount,
-                failureCode: delivery.unconfirmed ? 'paste_not_confirmed' : undefined,
-            });
-            const updated = this.messageLog.getById(logEntry.id);
-            if (updated) {
-                if (delivery.unconfirmed)
-                    this.activityStream.broadcastUnconfirmed(logEntry.id, [updated]);
-                else
-                    this.activityStream.broadcastDelivered(logEntry.id, [updated]);
-            }
+            const result = this.recordImmediateDelivered(logEntry.id, delivery);
             if (expectedSubmit &&
                 expectedSubmit.sessionId === delivery.sessionId &&
                 expectedSubmit.tmuxSessionName === delivery.tmuxSessionName) {
                 await this.completeHumanSubmitUnderAgentLock(input.agentId, delivery.sessionId, delivery.tmuxSessionName, expectedSubmit.generation);
             }
-            return { status, logEntryId: logEntry.id };
+            return result;
         }
         catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(input.failureDisclosure, errorMsg, 'tmux_error');
-            logger.error({ agentId: input.agentId, source: input.source, error: failure.error }, 'Immediate delivery failed');
-            this.messageLog.update(logEntry.id, {
-                status: 'failed',
-                error: failure.error,
-                failureCode: failure.failureCode,
-            });
-            const failed = this.messageLog.getById(logEntry.id);
-            if (failed)
-                this.activityStream.broadcastFailed(failed);
-            return { status: 'failed', error: failure.error, logEntryId: logEntry.id };
+            return this.recordImmediateFailed(input, error);
         }
     }
     async completeHumanSubmitUnderAgentLock(agentId, sessionId, tmuxSessionName, expectedGeneration) {
@@ -1537,25 +1467,25 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
 };
 exports.SessionsMessagePoolService = SessionsMessagePoolService;
 __decorate([
-    (0, event_emitter_1.OnEvent)(session_human_prompt_state_changed_1.sessionHumanPromptStateChangedEvent.name, { suppressErrors: false }),
+    (0, on_catalog_event_1.OnCatalogEvent)(session_human_prompt_state_changed_1.sessionHumanPromptStateChangedEvent.name, { suppressErrors: false }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], SessionsMessagePoolService.prototype, "handleHumanPromptStateChanged", null);
 __decorate([
-    (0, event_emitter_1.OnEvent)('session.activity.changed', { async: true }),
+    (0, on_catalog_event_1.OnCatalogEvent)('session.activity.changed', { async: true }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], SessionsMessagePoolService.prototype, "handleSessionActivityChanged", null);
 __decorate([
-    (0, event_emitter_1.OnEvent)('session.stopped', { async: true }),
+    (0, on_catalog_event_1.OnCatalogEvent)('session.stopped', { async: true }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], SessionsMessagePoolService.prototype, "handleSessionStopped", null);
 __decorate([
-    (0, event_emitter_1.OnEvent)('session.crashed', { async: true }),
+    (0, on_catalog_event_1.OnCatalogEvent)('session.crashed', { async: true }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)