claude-flow 3.54.1 → 3.56.0

package/v3/@claude-flow/shared/dist/events/event-store.js

@@ -225,11 +225,15 @@ export class EventStore extends EventEmitter {
         // Order by timestamp
         sql += ' ORDER BY timestamp ASC';
         // Pagination
-        if (filter.limit) {
+        if (filter.limit !== undefined) {
             sql += ' LIMIT ?';
             params.push(filter.limit);
         }
-        if (filter.offset) {
+        else if (filter.offset !== undefined) {
+            // SQLite requires LIMIT before OFFSET; -1 means no upper bound.
+            sql += ' LIMIT -1';
+        }
+        if (filter.offset !== undefined) {
             sql += ' OFFSET ?';
             params.push(filter.offset);
         }

package/v3/@claude-flow/shared/dist/mcp/connection-pool.js

@@ -119,9 +119,12 @@ export class ConnectionPool extends EventEmitter {
     /**
      * Create a new connection
      */
-    async createConnection() {
+    async createConnection(reserved = false) {
         const id = `conn-${++this.connectionCounter}-${Date.now()}`;
         const connection = new ManagedConnection(id, this.transportType);
+        // Reserve before exposing it in the map or yielding to another acquirer.
+        if (reserved)
+            connection.state = 'busy';
         this.connections.set(id, connection);
         this.stats.totalCreated++;
         this.emit('pool:connection:created', { connectionId: id });
@@ -149,7 +152,7 @@ export class ConnectionPool extends EventEmitter {
         }
         // Create new connection if under limit
         if (this.connections.size < this.config.maxConnections) {
-            const connection = await this.createConnection();
+            const connection = await this.createConnection(true);
             connection.acquire();
             this.stats.totalAcquired++;
             this.recordAcquireTime(startTime);

package/v3/@claude-flow/shared/dist/resilience/bulkhead-sync-throw.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bulkhead-sync-throw.test.d.ts.map

package/v3/@claude-flow/shared/dist/resilience/bulkhead-sync-throw.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { Bulkhead } from './bulkhead.js';
+describe('queued bulkhead failures', () => {
+    it('rejects the throwing task and preserves the previous result and remaining capacity', async () => {
+        const bulkhead = new Bulkhead({
+            name: 'test',
+            maxConcurrent: 1,
+            maxQueue: 2,
+            queueTimeout: 100,
+        });
+        let release;
+        const first = bulkhead.execute(() => new Promise((resolve) => {
+            release = resolve;
+        }));
+        const failure = new Error('synchronous callback failure');
+        const second = bulkhead.execute(() => {
+            throw failure;
+        });
+        const secondResult = second.catch((error) => error);
+        const third = bulkhead.execute(async () => 'third');
+        release('first');
+        await expect(first).resolves.toBe('first');
+        expect(await secondResult).toBe(failure);
+        await expect(third).resolves.toBe('third');
+        await Promise.resolve();
+        expect(bulkhead.getStats()).toMatchObject({
+            active: 0,
+            queued: 0,
+            completed: 2,
+        });
+    });
+});
+//# sourceMappingURL=bulkhead-sync-throw.test.js.map

package/v3/@claude-flow/shared/dist/resilience/bulkhead.js

@@ -158,7 +158,8 @@ export class Bulkhead extends EventEmitter {
         // Execute the queued function
         this.active++;
         this.emit('acquire');
-        item.fn()
+        Promise.resolve()
+            .then(() => item.fn())
             .then((result) => {
             this.completed++;
             item.resolve(result);

package/v3/@claude-flow/shared/dist/resilience/retry-timeout-cleanup.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry-timeout-cleanup.test.d.ts.map

package/v3/@claude-flow/shared/dist/resilience/retry-timeout-cleanup.test.js

@@ -0,0 +1,38 @@
+import { afterEach, describe, it, expect, vi } from 'vitest';
+import { retry } from './retry.js';
+afterEach(() => vi.useRealTimers());
+describe('retry timeout lifetime', () => {
+    it('does not keep a success timer alive after an attempt settles', async () => {
+        vi.useFakeTimers();
+        const result = await retry(async () => 42, {
+            maxAttempts: 1,
+            timeout: 30000,
+        });
+        expect(result.success).toBe(true);
+        expect(result.result).toBe(42);
+        expect(vi.getTimerCount()).toBe(0);
+    });
+    it('releases timers for rejected attempts without suppressing their errors', async () => {
+        vi.useFakeTimers();
+        const err = new Error('no');
+        const result = await retry(async () => {
+            throw err;
+        }, { maxAttempts: 1 });
+        expect(result.success).toBe(false);
+        expect(result.errors).toEqual([err]);
+        expect(vi.getTimerCount()).toBe(0);
+    });
+    it('still bounds a pending operation and reports the timeout', async () => {
+        vi.useFakeTimers();
+        const promise = retry(() => new Promise(() => { }), {
+            maxAttempts: 1,
+            timeout: 10,
+        });
+        await vi.advanceTimersByTimeAsync(10);
+        const result = await promise;
+        expect(result.success).toBe(false);
+        expect(result.errors[0].message).toContain('timed out');
+        expect(vi.getTimerCount()).toBe(0);
+    });
+});
+//# sourceMappingURL=retry-timeout-cleanup.test.js.map

package/v3/@claude-flow/shared/dist/resilience/retry.js

@@ -117,12 +117,19 @@ export function withRetry(fn, options = {}) {
  * Execute with timeout
  */
 async function withTimeout(promise, timeout, attempt) {
+    let timer;
     const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
+        timer = setTimeout(() => {
             reject(new Error(`Attempt ${attempt} timed out after ${timeout}ms`));
         }, timeout);
     });
-    return Promise.race([promise, timeoutPromise]);
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
 }
 /**
  * Sleep for specified milliseconds

package/v3/@claude-flow/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/shared",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "type": "module",
   "description": "Shared module - common types, events, utilities, core interfaces",
   "main": "dist/index.js",