claude-flow-novice 1.6.4 → 1.6.5

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/resource-manager-safe.js

@@ -0,0 +1,478 @@
+/**
+ * Thread-Safe Resource Manager (Phase 8 Preparation)
+ *
+ * Rust-inspired concurrency patterns applied to TypeScript:
+ * - Atomic test-and-set for lock acquisition
+ * - Immutable queue updates for wait queue
+ * - Hard resource limits for DoS prevention
+ * - No race conditions in critical sections
+ *
+ * @module coordination/v2/core/resource-manager-safe
+ */ /**
+ * Thread-safe resource manager with deadlock prevention.
+ *
+ * Key safety properties:
+ * 1. Atomic lock operations (no check-then-act races)
+ * 2. Immutable wait queue updates (no concurrent modification)
+ * 3. Hard resource limits (prevents DoS)
+ * 4. Automatic stale lock cleanup
+ *
+ * Rust equivalent patterns:
+ * - Arc<RwLock<HashMap<ResourceId, AgentId>>> for locks
+ * - Arc<Mutex<BinaryHeap<LockRequest>>> for wait queue
+ * - Automatic Drop cleanup for stale locks
+ */ export class SafeResourceManager {
+    config;
+    resources = new Map();
+    locks = new Map();
+    waitQueues = new Map();
+    agentResources = new Map();
+    // Concurrency control
+    operationLock = false;
+    cleanupInterval;
+    constructor(config){
+        this.config = config;
+        // Start periodic cleanup (equivalent to Rust's background task)
+        this.cleanupInterval = setInterval(()=>{
+            this.cleanupStaleLocks().catch(console.error);
+        }, 30000);
+    }
+    /**
+   * Acquire resource lock with atomic test-and-set.
+   *
+   * Rust equivalent:
+   * ```rust
+   * let guard = resource.lock.compare_exchange(
+   *     false, true, Ordering::AcqRel, Ordering::Acquire
+   * )?;
+   * ```
+   *
+   * @param resourceId - Resource to acquire
+   * @param agentId - Agent requesting lock
+   * @param priority - Request priority (higher = more urgent)
+   */ async acquire(resourceId, agentId, priority = 0) {
+        return this.withOperationLock(async ()=>{
+            // Check hard resource limit (DoS prevention)
+            if (this.resources.size >= this.config.maxResources && !this.resources.has(resourceId)) {
+                throw new Error(`Resource limit reached (${this.config.maxResources} max)`);
+            }
+            // Ensure resource exists
+            if (!this.resources.has(resourceId)) {
+                this.resources.set(resourceId, {
+                    id: resourceId,
+                    type: 'generic',
+                    locked: false
+                });
+            }
+            // ATOMIC: Try to acquire lock
+            const acquired = this.tryAcquireLock(resourceId, agentId);
+            if (acquired) {
+                return; // Success - lock acquired
+            }
+            // Lock already held - add to wait queue
+            await this.enqueueWaitRequest(resourceId, agentId, priority);
+        });
+    }
+    /**
+   * Release resource lock and grant to next waiter.
+   *
+   * Rust equivalent:
+   * ```rust
+   * drop(guard); // Automatically releases lock
+   * if let Some(next) = wait_queue.pop() {
+   *     grant_lock(next);
+   * }
+   * ```
+   */ async release(resourceId, agentId) {
+        return this.withOperationLock(async ()=>{
+            const currentLock = this.locks.get(resourceId);
+            if (currentLock !== agentId) {
+                console.warn(`[ResourceManager] Agent ${agentId} attempted to release unowned resource ${resourceId}`);
+                return;
+            }
+            // Release lock
+            this.releaseLock(resourceId, agentId);
+            // Grant to next in queue
+            const queue = this.waitQueues.get(resourceId);
+            if (queue && queue.length > 0) {
+                // Remove first waiter (immutable update)
+                const [nextRequest, ...remainingQueue] = queue;
+                this.waitQueues.set(resourceId, remainingQueue);
+                // Grant lock atomically
+                this.grantLock(resourceId, nextRequest.agentId);
+                console.log(`[ResourceManager] Lock granted to ${nextRequest.agentId} for ${resourceId}`);
+            }
+        });
+    }
+    /**
+   * Release all resources held by agent.
+   * Used during agent shutdown or deadlock recovery.
+   */ async releaseAllForAgent(agentId) {
+        const resourceIds = this.agentResources.get(agentId);
+        if (!resourceIds) return;
+        for (const resourceId of Array.from(resourceIds)){
+            await this.release(resourceId, agentId);
+        }
+        this.agentResources.delete(agentId);
+    }
+    /**
+   * Get current resource allocations (for WFG construction).
+   */ getAllocations() {
+        return new Map(this.locks);
+    }
+    /**
+   * Get waiting agents (for WFG edge construction).
+   * Returns map of agentId → resources they're waiting for.
+   */ getWaitingAgents() {
+        const waiting = new Map();
+        for (const [resourceId, queue] of Array.from(this.waitQueues.entries())){
+            for (const request of queue){
+                const resources = waiting.get(request.agentId) || [];
+                resources.push(resourceId);
+                waiting.set(request.agentId, resources);
+            }
+        }
+        return waiting;
+    }
+    /**
+   * Cleanup stale locks (automatic Drop-like behavior).
+   *
+   * Rust equivalent:
+   * ```rust
+   * impl Drop for ResourceGuard {
+   *     fn drop(&mut self) {
+   *         if self.held_too_long() {
+   *             force_release(self.resource_id);
+   *         }
+   *     }
+   * }
+   * ```
+   */ async cleanupStaleLocks() {
+        return this.withOperationLock(async ()=>{
+            const now = Date.now();
+            const staleThreshold = this.config.resourceTimeout * 2;
+            for (const [resourceId, agentId] of Array.from(this.locks)){
+                const resource = this.resources.get(resourceId);
+                if (!resource?.lockedAt) continue;
+                const lockAge = now - resource.lockedAt;
+                if (lockAge > staleThreshold) {
+                    console.warn(`[ResourceManager] Force releasing stale lock: ${resourceId} held by ${agentId} for ${lockAge}ms`);
+                    this.releaseLock(resourceId, agentId);
+                }
+            }
+            // Cleanup stale wait requests
+            for (const [resourceId, queue] of Array.from(this.waitQueues)){
+                const fresh = queue.filter((req)=>{
+                    const age = now - req.timestamp;
+                    if (age > this.config.maxWaitTime) {
+                        console.warn(`[ResourceManager] Removing stale wait request: ${req.agentId} waiting ${age}ms`);
+                        return false;
+                    }
+                    return true;
+                });
+                if (fresh.length === 0) {
+                    this.waitQueues.delete(resourceId);
+                } else {
+                    this.waitQueues.set(resourceId, fresh);
+                }
+            }
+        });
+    }
+    /**
+   * Atomic test-and-set lock operation.
+   *
+   * CRITICAL: This must be atomic to prevent race conditions.
+   * Returns true if lock was acquired, false otherwise.
+   */ tryAcquireLock(resourceId, agentId) {
+        const resource = this.resources.get(resourceId);
+        // Check if already locked (atomic read)
+        if (resource.locked) {
+            // Already locked by someone else
+            if (resource.lockedBy !== agentId) {
+                return false;
+            }
+            // Already locked by us (re-entrant lock)
+            return true;
+        }
+        // Atomically set lock flag and metadata
+        resource.locked = true;
+        resource.lockedBy = agentId;
+        resource.lockedAt = Date.now();
+        this.locks.set(resourceId, agentId);
+        // Track agent resources
+        if (!this.agentResources.has(agentId)) {
+            this.agentResources.set(agentId, new Set());
+        }
+        this.agentResources.get(agentId).add(resourceId);
+        console.log(`[ResourceManager] Lock acquired: ${resourceId} by ${agentId}`);
+        return true;
+    }
+    /**
+   * Grant lock to specific agent (used after queue processing).
+   */ grantLock(resourceId, agentId) {
+        const resource = this.resources.get(resourceId);
+        resource.locked = true;
+        resource.lockedBy = agentId;
+        resource.lockedAt = Date.now();
+        this.locks.set(resourceId, agentId);
+        if (!this.agentResources.has(agentId)) {
+            this.agentResources.set(agentId, new Set());
+        }
+        this.agentResources.get(agentId).add(resourceId);
+    }
+    /**
+   * Release lock (internal - assumes caller holds operation lock).
+   */ releaseLock(resourceId, agentId) {
+        const resource = this.resources.get(resourceId);
+        if (!resource) return;
+        resource.locked = false;
+        delete resource.lockedBy;
+        delete resource.lockedAt;
+        this.locks.delete(resourceId);
+        this.agentResources.get(agentId)?.delete(resourceId);
+        console.log(`[ResourceManager] Lock released: ${resourceId} by ${agentId}`);
+    }
+    /**
+   * Add request to wait queue with priority ordering (immutable update).
+   *
+   * Rust equivalent:
+   * ```rust
+   * let mut queue = self.wait_queue.lock().unwrap();
+   * queue.push(request);
+   * queue.sort_by_key(|r| (Reverse(r.priority), r.timestamp));
+   * ```
+   */ async enqueueWaitRequest(resourceId, agentId, priority) {
+        const request = {
+            agentId,
+            resourceId,
+            timestamp: Date.now(),
+            priority
+        };
+        // IMMUTABLE UPDATE: Create new sorted queue
+        const oldQueue = this.waitQueues.get(resourceId) || [];
+        const newQueue = [
+            ...oldQueue,
+            request
+        ].sort((a, b)=>{
+            // Higher priority first, then FIFO
+            if (a.priority !== b.priority) {
+                return b.priority - a.priority;
+            }
+            return a.timestamp - b.timestamp;
+        });
+        this.waitQueues.set(resourceId, newQueue);
+        console.log(`[ResourceManager] Agent ${agentId} enqueued for ${resourceId} (priority=${priority}, queue_len=${newQueue.length})`);
+        // Wait for lock with timeout
+        const startTime = Date.now();
+        while(Date.now() - startTime < this.config.maxWaitTime){
+            // Check if we got the lock
+            if (this.locks.get(resourceId) === agentId) {
+                return; // Success
+            }
+            // Check if still in queue
+            const currentQueue = this.waitQueues.get(resourceId) || [];
+            if (!currentQueue.some((req)=>req.agentId === agentId)) {
+                throw new Error(`Wait request cancelled for ${resourceId}`);
+            }
+            // Yield CPU
+            await new Promise((resolve)=>setImmediate(resolve));
+        }
+        // Timeout - remove from queue
+        const finalQueue = this.waitQueues.get(resourceId) || [];
+        const filtered = finalQueue.filter((req)=>req.agentId !== agentId);
+        this.waitQueues.set(resourceId, filtered);
+        throw new Error(`Resource acquisition timeout for ${resourceId} (waited ${this.config.maxWaitTime}ms)`);
+    }
+    /**
+   * Operation lock helper (prevents concurrent state modifications).
+   *
+   * Rust equivalent:
+   * ```rust
+   * async fn with_lock<T, F>(&self, f: F) -> T
+   * where F: FnOnce() -> T {
+   *     let _guard = self.lock.lock().await;
+   *     f()
+   * }
+   * ```
+   */ async withOperationLock(fn) {
+        // Spin-lock (simple re-entrance guard)
+        while(this.operationLock){
+            await new Promise((resolve)=>setImmediate(resolve));
+        }
+        this.operationLock = true;
+        try {
+            return await fn();
+        } finally{
+            this.operationLock = false;
+        }
+    }
+    /**
+   * Shutdown gracefully.
+   */ async shutdown() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        // Final cleanup
+        await this.cleanupStaleLocks();
+        // Release all locks
+        for (const [resourceId, agentId] of Array.from(this.locks)){
+            this.releaseLock(resourceId, agentId);
+        }
+        this.resources.clear();
+        this.locks.clear();
+        this.waitQueues.clear();
+        this.agentResources.clear();
+    }
+    /**
+   * Health check metrics.
+   */ getHealthStatus() {
+        const now = Date.now();
+        let totalLockAge = 0;
+        let lockedCount = 0;
+        for (const [resourceId] of Array.from(this.locks.entries())){
+            const resource = this.resources.get(resourceId);
+            if (resource?.lockedAt) {
+                totalLockAge += now - resource.lockedAt;
+                lockedCount++;
+            }
+        }
+        const waitingAgents = new Set();
+        let totalWaiting = 0;
+        for (const queue of Array.from(this.waitQueues.values())){
+            totalWaiting += queue.length;
+            queue.forEach((req)=>waitingAgents.add(req.agentId));
+        }
+        return {
+            healthy: true,
+            metrics: {
+                totalResources: this.resources.size,
+                lockedResources: this.locks.size,
+                freeResources: this.resources.size - this.locks.size,
+                waitingAgents: waitingAgents.size,
+                totalWaitingRequests: totalWaiting,
+                averageLockAge: lockedCount > 0 ? totalLockAge / lockedCount : 0
+            }
+        };
+    }
+}
+/**
+ * Wait-For-Graph for deadlock detection (Phase 8).
+ *
+ * Rust equivalent:
+ * ```rust
+ * struct WaitForGraph {
+ *     edges: Arc<RwLock<HashMap<AgentId, HashSet<AgentId>>>>,
+ * }
+ * ```
+ */ export class WaitForGraph {
+    edges = new Map();
+    lock = false;
+    /**
+   * Add wait relationship: waiter is waiting for holder.
+   */ async addEdge(waiter, holder) {
+        return this.withLock(async ()=>{
+            if (!this.edges.has(waiter)) {
+                this.edges.set(waiter, new Set());
+            }
+            this.edges.get(waiter).add(holder);
+        });
+    }
+    /**
+   * Remove wait relationship.
+   */ async removeEdge(waiter, holder) {
+        return this.withLock(async ()=>{
+            const holders = this.edges.get(waiter);
+            if (holders) {
+                holders.delete(holder);
+                if (holders.size === 0) {
+                    this.edges.delete(waiter);
+                }
+            }
+        });
+    }
+    /**
+   * Detect cycle using DFS (returns cycle path if found).
+   *
+   * Rust equivalent:
+   * ```rust
+   * fn detect_cycle(&self) -> Option<Vec<AgentId>> {
+   *     let graph = self.edges.read().unwrap();
+   *     // DFS with visited/stack sets
+   * }
+   * ```
+   */ async detectCycle() {
+        return this.withLock(async ()=>{
+            const visited = new Set();
+            const stack = new Set();
+            for (const node of Array.from(this.edges.keys())){
+                if (!visited.has(node)) {
+                    const cycle = this.dfs(node, visited, stack, []);
+                    if (cycle) return cycle;
+                }
+            }
+            return null;
+        });
+    }
+    /**
+   * DFS cycle detection (internal).
+   */ dfs(node, visited, stack, path) {
+        visited.add(node);
+        stack.add(node);
+        path.push(node);
+        const neighbors = this.edges.get(node) || new Set();
+        for (const neighbor of Array.from(neighbors)){
+            if (!visited.has(neighbor)) {
+                const cycle = this.dfs(neighbor, visited, stack, [
+                    ...path
+                ]);
+                if (cycle) return cycle;
+            } else if (stack.has(neighbor)) {
+                // Cycle found - extract cycle path
+                const cycleStart = path.indexOf(neighbor);
+                return path.slice(cycleStart);
+            }
+        }
+        stack.delete(node);
+        return null;
+    }
+    /**
+   * Create immutable snapshot of graph.
+   *
+   * Rust equivalent:
+   * ```rust
+   * fn snapshot(&self) -> HashMap<AgentId, HashSet<AgentId>> {
+   *     self.edges.read().unwrap().clone()
+   * }
+   * ```
+   */ async snapshot() {
+        return this.withLock(async ()=>{
+            return new Map(Array.from(this.edges.entries()).map(([k, v])=>[
+                    k,
+                    new Set(v)
+                ]));
+        });
+    }
+    /**
+   * Clear all edges.
+   */ async clear() {
+        return this.withLock(async ()=>{
+            this.edges.clear();
+        });
+    }
+    /**
+   * Lock helper for atomic operations.
+   */ async withLock(fn) {
+        while(this.lock){
+            await new Promise((resolve)=>setImmediate(resolve));
+        }
+        this.lock = true;
+        try {
+            return await fn();
+        } finally{
+            this.lock = false;
+        }
+    }
+}
+
+//# sourceMappingURL=resource-manager-safe.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/resource-manager-safe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/core/resource-manager-safe.ts"],"names":["SafeResourceManager","resources","Map","locks","waitQueues","agentResources","operationLock","cleanupInterval","config","setInterval","cleanupStaleLocks","catch","console","error","acquire","resourceId","agentId","priority","withOperationLock","size","maxResources","has","Error","set","id","type","locked","acquired","tryAcquireLock","enqueueWaitRequest","release","currentLock","get","warn","releaseLock","queue","length","nextRequest","remainingQueue","grantLock","log","releaseAllForAgent","resourceIds","Array","from","delete","getAllocations","getWaitingAgents","waiting","entries","request","push","now","Date","staleThreshold","resourceTimeout","resource","lockedAt","lockAge","fresh","filter","req","age","timestamp","maxWaitTime","lockedBy","Set","add","oldQueue","newQueue","sort","a","b","startTime","currentQueue","some","Promise","resolve","setImmediate","finalQueue","filtered","fn","shutdown","clearInterval","undefined","clear","getHealthStatus","totalLockAge","lockedCount","waitingAgents","totalWaiting","values","forEach","healthy","metrics","totalResources","lockedResources","freeResources","totalWaitingRequests","averageLockAge","WaitForGraph","edges","lock","addEdge","waiter","holder","withLock","removeEdge","holders","detectCycle","visited","stack","node","keys","cycle","dfs","path","neighbors","neighbor","cycleStart","indexOf","slice","snapshot","map","k","v"],"mappings":"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"}