Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(swarm): cancel queued subscriber delivery at shutdown (#4233)

Rudy Mizrahi Celekli0793f9624808
diff --git a/v3/@claude-flow/swarm/__tests__/message-bus.shutdown-boundary.test.ts b/v3/@claude-flow/swarm/__tests__/message-bus.shutdown-boundary.test.ts
new file mode 100644
index 0000000000..991b7462fe
--- /dev/null
+++ b/v3/@claude-flow/swarm/__tests__/message-bus.shutdown-boundary.test.ts
@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { createMessageBus, type MessageBus } from '../src/message-bus.js';
+
+const nextTurn = () => new Promise<void>((resolve) => setImmediate(resolve));
+const message = (to: string) => ({
+ type: 'direct' as const,
+ from: 'sender',
+ to,
+ payload: {},
+ priority: 'normal' as const,
+ requiresAck: false,
+ ttlMs: 60_000,
+});
+
+let bus: MessageBus;
+afterEach(async () => { await bus.shutdown(); });
+
+describe('MessageBus shutdown delivery boundary', () => {
+ it('does not invoke a queued subscriber after shutdown has completed', async () => {
+ bus = createMessageBus({ processingIntervalMs: 5000 });
+ await bus.initialize();
+ const observed: string[] = [];
+ bus.subscribe('target', () => { observed.push('subscriber side effect'); });
+ bus.on('shutdown', () => { observed.push('shutdown'); });
+ bus.on('message.delivered', () => { observed.push('delivered'); });
+ await bus.send(message('target'));
+ // Drain the dispatch pass while its subscriber callbacks remain queued.
+ await nextTurn();
+ await bus.shutdown();
+ await nextTurn();
+ expect(observed).toEqual(['shutdown']);
+ });
+
+ it('does not revive callbacks from the old lifecycle when immediately reinitialized', async () => {
+ bus = createMessageBus({ processingIntervalMs: 5000 });
+ await bus.initialize();
+ let oldSubscriber = 0;
+ let newSubscriber = 0;
+ bus.subscribe('target', () => { oldSubscriber++; });
+ await bus.send(message('target'));
+ await nextTurn();
+ await bus.shutdown();
+ await bus.initialize();
+ bus.subscribe('target', () => { newSubscriber++; });
+ await bus.send(message('target'));
+ await nextTurn();
+ await nextTurn();
+ expect(oldSubscriber).toBe(0);
+ expect(newSubscriber).toBe(1);
+ });
+
+ it('cancels the other queued subscriber when the first subscriber shuts down the bus', async () => {
+ bus = createMessageBus({ processingIntervalMs: 5000 });
+ await bus.initialize();
+ const observed: string[] = [];
+ bus.subscribe('first', () => {
+ observed.push('first');
+ void bus.shutdown();
+ });
+ bus.subscribe('second', () => { observed.push('second'); });
+ await bus.send(message('first'));
+ await bus.send(message('second'));
+ await nextTurn();
+ await nextTurn();
+ expect(observed).toEqual(['first']);
+ });
+});
diff --git a/v3/@claude-flow/swarm/src/message-bus.ts b/v3/@claude-flow/swarm/src/message-bus.ts
index 9745c0928f..910e2db8ca 100644
--- a/v3/@claude-flow/swarm/src/message-bus.ts
+++ b/v3/@claude-flow/swarm/src/message-bus.ts
@@ -229,6 +229,7 @@ export class MessageBus extends EventEmitter implements IMessageBus {
private statsInterval?: NodeJS.Timeout;
private processScheduled: boolean = false;
private isShutdown: boolean = false;
+ private deliveryImmediates: Set<NodeJS.Immediate> = new Set();
private messageCounter: number = 0;
private stats: MessageBusStats;
private startTime: Date = new Date();
@@ -292,6 +293,12 @@ export class MessageBus extends EventEmitter implements IMessageBus {
}
this.retryTimers.clear();
+ // Queue draining schedules subscriber callbacks separately. Cancel those
+ // pending callbacks too, including across a later initialize() call.
+ // A subscriber that is already running is not interrupted.
+ for (const delivery of this.deliveryImmediates) clearImmediate(delivery);
+ this.deliveryImmediates.clear();
+
if (this.processingInterval) {
clearInterval(this.processingInterval);
this.processingInterval = undefined;
@@ -537,8 +544,10 @@ export class MessageBus extends EventEmitter implements IMessageBus {
this.pendingAcks.set(message.id, { message, timeout });
}
- // Deliver asynchronously
- setImmediate(() => {
+ // Deliver asynchronously; shutdown owns and cancels pending handles.
+ const delivery = setImmediate(() => {
+ this.deliveryImmediates.delete(delivery);
+ if (this.isShutdown) return;
try {
subscription.callback(message);
this.emit('message.delivered', {
@@ -549,6 +558,7 @@ export class MessageBus extends EventEmitter implements IMessageBus {
this.handleDeliveryError(message, entry, error as Error, subscription.agentId);
}
});
+ this.deliveryImmediates.add(delivery);
} catch (error) {
this.handleDeliveryError(message, entry, error as Error, subscription.agentId);
}