@supaku/agentfactory-server 0.1.0

package/dist/src/issue-lock.js

@@ -0,0 +1,499 @@
+/**
+ * Issue Lock Module
+ *
+ * Prevents overlapping agents for the same issue by providing:
+ * - Per-issue mutex (Redis SET NX) that gates work dispatch
+ * - Per-issue pending queue for parking incoming work while locked
+ * - Automatic promotion: releasing a lock dispatches the next pending item
+ *
+ * Redis Keys:
+ * - issue:lock:{issueId}         -- String (JSON IssueLock), 2hr TTL
+ * - issue:pending:{issueId}      -- Sorted Set (priority-ordered session IDs)
+ * - issue:pending:items:{issueId} -- Hash (sessionId -> JSON QueuedWork)
+ */
+import { redisSetNX, redisGet, redisDel, redisExpire, redisZAdd, redisZRem, redisZPopMin, redisZCard, redisHSet, redisHGet, redisHDel, redisHGetAll, isRedisConfigured, redisKeys, } from './redis';
+import { queueWork } from './work-queue';
+import { getSessionState } from './session-storage';
+const log = {
+    info: (msg, data) => console.log(`[issue-lock] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[issue-lock] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[issue-lock] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+// Redis key prefixes
+const LOCK_PREFIX = 'issue:lock:';
+const PENDING_PREFIX = 'issue:pending:';
+const PENDING_ITEMS_PREFIX = 'issue:pending:items:';
+// Default lock TTL: 2 hours
+const LOCK_TTL_SECONDS = 2 * 60 * 60;
+// Pending queue TTL: 24 hours
+const PENDING_TTL_SECONDS = 24 * 60 * 60;
+/**
+ * Acquire an issue-level lock.
+ * Uses SET NX for atomicity -- only one caller wins.
+ *
+ * @returns true if lock was acquired
+ */
+export async function acquireIssueLock(issueId, lock) {
+    if (!isRedisConfigured()) {
+        return true; // No Redis = no locking, pass through
+    }
+    try {
+        const key = `${LOCK_PREFIX}${issueId}`;
+        const acquired = await redisSetNX(key, JSON.stringify(lock), LOCK_TTL_SECONDS);
+        if (acquired) {
+            log.info('Issue lock acquired', {
+                issueId,
+                sessionId: lock.sessionId,
+                workType: lock.workType,
+                issueIdentifier: lock.issueIdentifier,
+            });
+        }
+        else {
+            log.debug('Issue lock not acquired (already held)', {
+                issueId,
+                sessionId: lock.sessionId,
+            });
+        }
+        return acquired;
+    }
+    catch (error) {
+        log.error('Failed to acquire issue lock', { error, issueId });
+        return false;
+    }
+}
+/**
+ * Read the current lock for an issue.
+ */
+export async function getIssueLock(issueId) {
+    if (!isRedisConfigured())
+        return null;
+    try {
+        const key = `${LOCK_PREFIX}${issueId}`;
+        // redisSetNX stores the raw JSON string; redisGet parses it back
+        // Since redisSetNX stores JSON.stringify(lock), redisGet returns the parsed lock directly
+        return await redisGet(key);
+    }
+    catch (error) {
+        log.error('Failed to get issue lock', { error, issueId });
+        return null;
+    }
+}
+/**
+ * Release an issue lock. Idempotent.
+ */
+export async function releaseIssueLock(issueId) {
+    if (!isRedisConfigured())
+        return;
+    try {
+        const key = `${LOCK_PREFIX}${issueId}`;
+        await redisDel(key);
+        log.info('Issue lock released', { issueId });
+    }
+    catch (error) {
+        log.error('Failed to release issue lock', { error, issueId });
+    }
+}
+/**
+ * Refresh the TTL on an issue lock (extend while agent is alive).
+ */
+export async function refreshIssueLockTTL(issueId, ttlSeconds = LOCK_TTL_SECONDS) {
+    if (!isRedisConfigured())
+        return false;
+    try {
+        const key = `${LOCK_PREFIX}${issueId}`;
+        return await redisExpire(key, ttlSeconds);
+    }
+    catch (error) {
+        log.error('Failed to refresh issue lock TTL', { error, issueId });
+        return false;
+    }
+}
+/**
+ * Park work for a locked issue.
+ *
+ * Deduplication: at most one parked item per workType per issue.
+ * If a parked item with the same workType already exists, it's replaced
+ * (the latest webhook wins). Different workTypes can coexist.
+ */
+export async function parkWorkForIssue(issueId, work) {
+    if (!isRedisConfigured()) {
+        return { parked: false, replaced: false };
+    }
+    try {
+        const pendingKey = `${PENDING_PREFIX}${issueId}`;
+        const itemsKey = `${PENDING_ITEMS_PREFIX}${issueId}`;
+        const workType = work.workType || 'development';
+        // Dedup key: use workType as the sorted set member
+        // This means at most one pending item per workType
+        const dedupMember = workType;
+        // Check if there's already a parked item with this workType
+        const existing = await redisHGet(itemsKey, dedupMember);
+        const replaced = !!existing;
+        if (replaced) {
+            // Remove old entry from sorted set before adding new one
+            await redisZRem(pendingKey, dedupMember);
+            log.info('Replacing existing parked work', {
+                issueId,
+                workType,
+                sessionId: work.sessionId,
+            });
+        }
+        // Score = priority (lower = higher priority)
+        const score = work.priority;
+        // Add to sorted set and hash
+        await redisZAdd(pendingKey, score, dedupMember);
+        await redisHSet(itemsKey, dedupMember, JSON.stringify(work));
+        // Set TTL on both keys
+        await redisExpire(pendingKey, PENDING_TTL_SECONDS);
+        await redisExpire(itemsKey, PENDING_TTL_SECONDS);
+        log.info('Work parked for issue', {
+            issueId,
+            workType,
+            sessionId: work.sessionId,
+            priority: work.priority,
+            replaced,
+        });
+        return { parked: true, replaced };
+    }
+    catch (error) {
+        log.error('Failed to park work for issue', { error, issueId });
+        return { parked: false, replaced: false };
+    }
+}
+/**
+ * Promote the next pending work item for an issue.
+ * Pops the highest-priority item, acquires the issue lock for it,
+ * and queues it in the global work queue.
+ *
+ * @returns The promoted work item, or null if nothing to promote
+ */
+export async function promoteNextPendingWork(issueId) {
+    if (!isRedisConfigured())
+        return null;
+    try {
+        const pendingKey = `${PENDING_PREFIX}${issueId}`;
+        const itemsKey = `${PENDING_ITEMS_PREFIX}${issueId}`;
+        // Pop the highest-priority (lowest score) member
+        const popped = await redisZPopMin(pendingKey);
+        if (!popped) {
+            log.debug('No pending work to promote', { issueId });
+            return null;
+        }
+        const dedupMember = popped.member;
+        // Get the work item from the hash
+        const workJson = await redisHGet(itemsKey, dedupMember);
+        if (!workJson) {
+            log.warn('Pending work item not found in hash', { issueId, dedupMember });
+            return null;
+        }
+        // Remove from hash
+        await redisHDel(itemsKey, dedupMember);
+        const work = JSON.parse(workJson);
+        // Acquire the issue lock for this promoted work
+        const lock = {
+            sessionId: work.sessionId,
+            workType: work.workType || 'development',
+            workerId: null,
+            lockedAt: Date.now(),
+            issueIdentifier: work.issueIdentifier,
+        };
+        const acquired = await acquireIssueLock(issueId, lock);
+        if (!acquired) {
+            log.warn('Failed to acquire lock for promoted work -- another lock appeared', {
+                issueId,
+                sessionId: work.sessionId,
+            });
+            // Re-park the work since we couldn't acquire the lock
+            await parkWorkForIssue(issueId, work);
+            return null;
+        }
+        // Queue in the global work queue
+        const queued = await queueWork(work);
+        if (!queued) {
+            log.error('Failed to queue promoted work', { issueId, sessionId: work.sessionId });
+            // Release the lock since we couldn't queue
+            await releaseIssueLock(issueId);
+            return null;
+        }
+        log.info('Pending work promoted', {
+            issueId,
+            sessionId: work.sessionId,
+            workType: work.workType,
+            issueIdentifier: work.issueIdentifier,
+        });
+        return work;
+    }
+    catch (error) {
+        log.error('Failed to promote pending work', { error, issueId });
+        return null;
+    }
+}
+/**
+ * Get the count of pending work items for an issue.
+ */
+export async function getPendingWorkCount(issueId) {
+    if (!isRedisConfigured())
+        return 0;
+    try {
+        const pendingKey = `${PENDING_PREFIX}${issueId}`;
+        return await redisZCard(pendingKey);
+    }
+    catch (error) {
+        log.error('Failed to get pending work count', { error, issueId });
+        return 0;
+    }
+}
+/**
+ * Main entry point for dispatching work.
+ *
+ * Try to acquire the issue lock:
+ * - If acquired -> queue the work in the global queue
+ * - If locked -> park the work in the per-issue pending queue
+ *
+ * @returns DispatchResult indicating what happened
+ */
+export async function dispatchWork(work) {
+    if (!isRedisConfigured()) {
+        // No Redis -- fall back to direct queueing (no locking)
+        const queued = await queueWork(work);
+        return { dispatched: queued, parked: false, replaced: false };
+    }
+    const issueId = work.issueId;
+    // Try to acquire the issue lock
+    const lock = {
+        sessionId: work.sessionId,
+        workType: work.workType || 'development',
+        workerId: null,
+        lockedAt: Date.now(),
+        issueIdentifier: work.issueIdentifier,
+    };
+    const acquired = await acquireIssueLock(issueId, lock);
+    if (acquired) {
+        // Lock acquired -- dispatch to global queue
+        const queued = await queueWork(work);
+        if (!queued) {
+            // Failed to queue -- release the lock
+            await releaseIssueLock(issueId);
+            return { dispatched: false, parked: false, replaced: false };
+        }
+        log.info('Work dispatched (lock acquired)', {
+            issueId,
+            sessionId: work.sessionId,
+            workType: work.workType,
+            issueIdentifier: work.issueIdentifier,
+        });
+        return { dispatched: true, parked: false, replaced: false };
+    }
+    // Lock held by another session -- park this work
+    const { parked, replaced } = await parkWorkForIssue(issueId, work);
+    if (parked) {
+        log.info('Work parked (issue locked)', {
+            issueId,
+            sessionId: work.sessionId,
+            workType: work.workType,
+            replaced,
+        });
+    }
+    return { dispatched: false, parked, replaced };
+}
+/**
+ * Remove a parked work item by sessionId.
+ *
+ * The issue-pending hash is keyed by workType, so we scan all entries
+ * to find the one matching the given sessionId.
+ *
+ * @returns true if a matching parked item was found and removed
+ */
+export async function removeParkedWorkBySessionId(issueId, sessionId) {
+    if (!isRedisConfigured())
+        return false;
+    try {
+        const pendingKey = `${PENDING_PREFIX}${issueId}`;
+        const itemsKey = `${PENDING_ITEMS_PREFIX}${issueId}`;
+        // Get all entries in the hash (keyed by workType)
+        const entries = await redisHGetAll(itemsKey);
+        if (!entries)
+            return false;
+        for (const [dedupMember, workJson] of Object.entries(entries)) {
+            try {
+                const work = JSON.parse(workJson);
+                if (work.sessionId === sessionId) {
+                    // Found the matching entry -- remove from both sorted set and hash
+                    await redisZRem(pendingKey, dedupMember);
+                    await redisHDel(itemsKey, dedupMember);
+                    log.info('Removed parked work by sessionId', {
+                        issueId,
+                        sessionId,
+                        workType: dedupMember,
+                    });
+                    return true;
+                }
+            }
+            catch {
+                // Skip malformed entries
+                continue;
+            }
+        }
+        log.debug('No parked work found for sessionId', { issueId, sessionId });
+        return false;
+    }
+    catch (error) {
+        log.error('Failed to remove parked work by sessionId', { error, issueId, sessionId });
+        return false;
+    }
+}
+/**
+ * Check if a session is parked in any issue-pending queue.
+ *
+ * Scans the issue:pending:items:{issueId} hash entries for a matching sessionId.
+ *
+ * @param issueId - The issue to check
+ * @param sessionId - The session to look for
+ * @returns true if the session is parked for this issue
+ */
+export async function isSessionParkedForIssue(issueId, sessionId) {
+    if (!isRedisConfigured())
+        return false;
+    try {
+        const itemsKey = `${PENDING_ITEMS_PREFIX}${issueId}`;
+        const entries = await redisHGetAll(itemsKey);
+        if (!entries)
+            return false;
+        for (const workJson of Object.values(entries)) {
+            try {
+                const work = JSON.parse(workJson);
+                if (work.sessionId === sessionId) {
+                    return true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        log.error('Failed to check if session is parked', { error, issueId, sessionId });
+        return false;
+    }
+}
+/**
+ * Scan for expired issue locks that have pending work.
+ * If a lock expired naturally (TTL) but pending items remain, promote them.
+ *
+ * Called from orphan-cleanup to handle crashed workers that didn't release locks.
+ */
+export async function cleanupExpiredLocksWithPendingWork() {
+    if (!isRedisConfigured())
+        return 0;
+    let promoted = 0;
+    try {
+        // Find all pending queues
+        const pendingKeys = await redisKeys(`${PENDING_PREFIX}*`);
+        for (const pendingKey of pendingKeys) {
+            // Extract issueId from key
+            const issueId = pendingKey.replace(PENDING_PREFIX, '');
+            // Check if lock still exists
+            const lockKey = `${LOCK_PREFIX}${issueId}`;
+            const lock = await redisGet(lockKey);
+            if (!lock) {
+                // Lock expired but pending work exists -- promote
+                const count = await redisZCard(pendingKey);
+                if (count > 0) {
+                    log.info('Found expired lock with pending work, promoting', {
+                        issueId,
+                        pendingCount: count,
+                    });
+                    const work = await promoteNextPendingWork(issueId);
+                    if (work) {
+                        promoted++;
+                    }
+                }
+            }
+        }
+        if (promoted > 0) {
+            log.info('Promoted pending work from expired locks', { promoted });
+        }
+    }
+    catch (error) {
+        log.error('Failed to cleanup expired locks', { error });
+    }
+    return promoted;
+}
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'stopped']);
+/**
+ * Release issue locks held by sessions that have already reached a terminal state.
+ *
+ * This handles the case where a session completes but the lock release failed
+ * (e.g., network error during cleanup). The lock's 2-hour TTL would eventually
+ * expire, but this proactively clears it when workers have idle capacity.
+ *
+ * Only runs when workers are online -- if no workers are available, there's no
+ * point promoting parked work since nothing can pick it up.
+ *
+ * @param hasIdleWorkers - true if at least one worker is online with spare capacity
+ * @returns Number of stale locks released and parked work promoted
+ */
+export async function cleanupStaleLocksWithIdleWorkers(hasIdleWorkers) {
+    if (!isRedisConfigured())
+        return 0;
+    if (!hasIdleWorkers)
+        return 0;
+    let promoted = 0;
+    try {
+        // Find all issue locks
+        const lockKeys = await redisKeys(`${LOCK_PREFIX}*`);
+        for (const lockKey of lockKeys) {
+            const issueId = lockKey.replace(LOCK_PREFIX, '');
+            // Skip keys that look like pending queue keys (contain extra colons)
+            if (issueId.includes(':'))
+                continue;
+            const lock = await redisGet(lockKey);
+            if (!lock)
+                continue;
+            // Check if the lock holder's session is in a terminal state
+            const session = await getSessionState(lock.sessionId);
+            if (!session) {
+                // Session expired from Redis (24h TTL) but lock remains (2h TTL)
+                // Safe to release -- the session is long gone
+                log.info('Releasing lock for expired session', {
+                    issueId,
+                    sessionId: lock.sessionId,
+                    issueIdentifier: lock.issueIdentifier,
+                });
+                await releaseIssueLock(issueId);
+                const work = await promoteNextPendingWork(issueId);
+                if (work)
+                    promoted++;
+                continue;
+            }
+            if (TERMINAL_STATUSES.has(session.status)) {
+                log.info('Releasing stale lock (session already terminal)', {
+                    issueId,
+                    sessionId: lock.sessionId,
+                    sessionStatus: session.status,
+                    issueIdentifier: lock.issueIdentifier,
+                    lockAge: Math.round((Date.now() - lock.lockedAt) / 1000),
+                });
+                await releaseIssueLock(issueId);
+                const work = await promoteNextPendingWork(issueId);
+                if (work) {
+                    promoted++;
+                    log.info('Promoted parked work after stale lock cleanup', {
+                        issueId,
+                        promotedSessionId: work.sessionId,
+                        promotedWorkType: work.workType,
+                    });
+                }
+            }
+        }
+        if (promoted > 0) {
+            log.info('Promoted parked work from stale locks', { promoted });
+        }
+    }
+    catch (error) {
+        log.error('Failed to cleanup stale locks', { error });
+    }
+    return promoted;
+}

package/dist/src/redis.d.ts

@@ -0,0 +1,146 @@
+import Redis from 'ioredis';
+/**
+ * Check if Redis is configured via REDIS_URL
+ */
+export declare function isRedisConfigured(): boolean;
+/**
+ * Get the shared Redis client instance
+ * Lazily initialized to avoid errors during build
+ */
+export declare function getRedisClient(): Redis;
+/**
+ * Disconnect Redis client (for graceful shutdown)
+ */
+export declare function disconnectRedis(): Promise<void>;
+/**
+ * Set a value with optional TTL (seconds)
+ */
+export declare function redisSet<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+/**
+ * Get a typed value
+ */
+export declare function redisGet<T>(key: string): Promise<T | null>;
+/**
+ * Delete a key
+ * @returns number of keys deleted (0 or 1)
+ */
+export declare function redisDel(key: string): Promise<number>;
+/**
+ * Check if a key exists
+ */
+export declare function redisExists(key: string): Promise<boolean>;
+/**
+ * Get keys matching a pattern
+ */
+export declare function redisKeys(pattern: string): Promise<string[]>;
+/**
+ * Push value to the right of a list (RPUSH)
+ * @returns length of list after push
+ */
+export declare function redisRPush(key: string, value: string): Promise<number>;
+/**
+ * Pop value from the left of a list (LPOP)
+ * @returns the popped value or null if list is empty
+ */
+export declare function redisLPop(key: string): Promise<string | null>;
+/**
+ * Get a range of elements from a list (LRANGE)
+ * @param start - Start index (0-based, inclusive)
+ * @param stop - Stop index (inclusive, -1 for end)
+ */
+export declare function redisLRange(key: string, start: number, stop: number): Promise<string[]>;
+/**
+ * Get the length of a list (LLEN)
+ */
+export declare function redisLLen(key: string): Promise<number>;
+/**
+ * Remove elements from a list (LREM)
+ * @param count - Number of occurrences to remove (0 = all)
+ * @returns number of elements removed
+ */
+export declare function redisLRem(key: string, count: number, value: string): Promise<number>;
+/**
+ * Add member to a set (SADD)
+ * @returns number of elements added (0 if already exists)
+ */
+export declare function redisSAdd(key: string, member: string): Promise<number>;
+/**
+ * Remove member from a set (SREM)
+ * @returns number of elements removed
+ */
+export declare function redisSRem(key: string, member: string): Promise<number>;
+/**
+ * Get all members of a set (SMEMBERS)
+ */
+export declare function redisSMembers(key: string): Promise<string[]>;
+/**
+ * Get the number of members in a set (SCARD)
+ */
+export declare function redisSCard(key: string): Promise<number>;
+/**
+ * Set a value only if key does not exist (SETNX)
+ * @returns true if key was set, false if it already existed
+ */
+export declare function redisSetNX(key: string, value: string, ttlSeconds?: number): Promise<boolean>;
+/**
+ * Set TTL on an existing key (EXPIRE)
+ * @returns true if TTL was set, false if key doesn't exist
+ */
+export declare function redisExpire(key: string, ttlSeconds: number): Promise<boolean>;
+/**
+ * Add member to a sorted set with score (ZADD)
+ * @returns number of elements added (0 if already exists, updates score)
+ */
+export declare function redisZAdd(key: string, score: number, member: string): Promise<number>;
+/**
+ * Remove member from a sorted set (ZREM)
+ * @returns number of elements removed
+ */
+export declare function redisZRem(key: string, member: string): Promise<number>;
+/**
+ * Get members from sorted set by score range (ZRANGEBYSCORE)
+ * Returns members with lowest scores first (highest priority)
+ * @param min - Minimum score (use '-inf' for no minimum)
+ * @param max - Maximum score (use '+inf' for no maximum)
+ * @param limit - Maximum number of results
+ */
+export declare function redisZRangeByScore(key: string, min: number | string, max: number | string, limit?: number): Promise<string[]>;
+/**
+ * Get the number of members in a sorted set (ZCARD)
+ */
+export declare function redisZCard(key: string): Promise<number>;
+/**
+ * Pop the member with the lowest score (ZPOPMIN)
+ * @returns [member, score] or null if set is empty
+ */
+export declare function redisZPopMin(key: string): Promise<{
+    member: string;
+    score: number;
+} | null>;
+/**
+ * Set a field in a hash (HSET)
+ * @returns 1 if field is new, 0 if field existed
+ */
+export declare function redisHSet(key: string, field: string, value: string): Promise<number>;
+/**
+ * Get a field from a hash (HGET)
+ */
+export declare function redisHGet(key: string, field: string): Promise<string | null>;
+/**
+ * Delete a field from a hash (HDEL)
+ * @returns number of fields removed
+ */
+export declare function redisHDel(key: string, field: string): Promise<number>;
+/**
+ * Get multiple fields from a hash (HMGET)
+ */
+export declare function redisHMGet(key: string, fields: string[]): Promise<(string | null)[]>;
+/**
+ * Get all fields and values from a hash (HGETALL)
+ */
+export declare function redisHGetAll(key: string): Promise<Record<string, string>>;
+/**
+ * Get the number of fields in a hash (HLEN)
+ */
+export declare function redisHLen(key: string): Promise<number>;
+//# sourceMappingURL=redis.d.ts.map

package/dist/src/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../src/redis.ts"],"names":[],"mappings":"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"}