@supaku/agentfactory-server 0.1.0

package/dist/src/worker-storage.js

@@ -0,0 +1,283 @@
+/**
+ * Worker Storage Module
+ *
+ * Manages worker registration and tracking in Redis.
+ * Workers register on startup, send periodic heartbeats,
+ * and deregister on shutdown.
+ */
+import crypto from 'crypto';
+import { redisSet, redisGet, redisDel, redisKeys, redisSAdd, redisSRem, redisSMembers, isRedisConfigured, } from './redis';
+const log = {
+    info: (msg, data) => console.log(`[worker] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[worker] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[worker] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+// Redis key constants
+const WORKER_PREFIX = 'work:worker:';
+const WORKER_SESSIONS_SUFFIX = ':sessions';
+// Default TTL for worker registration (120 seconds)
+// Worker must send heartbeat within this time or be considered offline
+const WORKER_TTL = parseInt(process.env.WORKER_TTL ?? '120', 10);
+// Heartbeat timeout (90 seconds = 3 missed 30-second heartbeats)
+const HEARTBEAT_TIMEOUT = parseInt(process.env.WORKER_HEARTBEAT_TIMEOUT ?? '90000', 10);
+// Configurable intervals (in milliseconds)
+const HEARTBEAT_INTERVAL = parseInt(process.env.WORKER_HEARTBEAT_INTERVAL ?? '30000', 10);
+const POLL_INTERVAL = parseInt(process.env.WORKER_POLL_INTERVAL ?? '5000', 10);
+/**
+ * Register a new worker
+ *
+ * @param hostname - Worker's hostname
+ * @param capacity - Maximum concurrent agents the worker can handle
+ * @param version - Optional worker software version
+ * @returns Worker ID and configuration
+ */
+export async function registerWorker(hostname, capacity, version) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot register worker');
+        return null;
+    }
+    try {
+        const workerId = `wkr_${crypto.randomUUID().replace(/-/g, '').slice(0, 16)}`;
+        const now = Date.now();
+        const workerData = {
+            id: workerId,
+            hostname,
+            capacity,
+            activeCount: 0,
+            registeredAt: now,
+            lastHeartbeat: now,
+            status: 'active',
+            version,
+        };
+        const key = `${WORKER_PREFIX}${workerId}`;
+        await redisSet(key, workerData, WORKER_TTL);
+        log.info('Worker registered', {
+            workerId,
+            hostname,
+            capacity,
+        });
+        return {
+            workerId,
+            heartbeatInterval: HEARTBEAT_INTERVAL,
+            pollInterval: POLL_INTERVAL,
+        };
+    }
+    catch (error) {
+        log.error('Failed to register worker', { error, hostname });
+        return null;
+    }
+}
+/**
+ * Update worker heartbeat
+ *
+ * @param workerId - Worker ID
+ * @param activeCount - Current number of active agents
+ * @param load - Optional system load metrics
+ * @returns Heartbeat acknowledgment or null on failure
+ */
+export async function updateHeartbeat(workerId, activeCount, load) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const key = `${WORKER_PREFIX}${workerId}`;
+        const worker = await redisGet(key);
+        if (!worker) {
+            log.warn('Heartbeat for unknown worker', { workerId });
+            return null;
+        }
+        // Update worker data
+        const updatedWorker = {
+            ...worker,
+            activeCount,
+            lastHeartbeat: Date.now(),
+            status: 'active',
+        };
+        // Reset TTL on heartbeat
+        await redisSet(key, updatedWorker, WORKER_TTL);
+        // Get pending work count (import dynamically to avoid circular dep)
+        const { getQueueLength } = await import('./work-queue');
+        const pendingWorkCount = await getQueueLength();
+        return {
+            acknowledged: true,
+            serverTime: new Date().toISOString(),
+            pendingWorkCount,
+        };
+    }
+    catch (error) {
+        log.error('Failed to update heartbeat', { error, workerId });
+        return null;
+    }
+}
+/**
+ * Get worker by ID
+ */
+export async function getWorker(workerId) {
+    if (!isRedisConfigured()) {
+        return null;
+    }
+    try {
+        const key = `${WORKER_PREFIX}${workerId}`;
+        const worker = await redisGet(key);
+        if (!worker) {
+            return null;
+        }
+        // Get active sessions for this worker
+        const sessionsKey = `${key}${WORKER_SESSIONS_SUFFIX}`;
+        const activeSessions = await redisSMembers(sessionsKey);
+        return {
+            ...worker,
+            activeSessions,
+        };
+    }
+    catch (error) {
+        log.error('Failed to get worker', { error, workerId });
+        return null;
+    }
+}
+/**
+ * Deregister a worker
+ *
+ * @param workerId - Worker ID to deregister
+ * @returns List of session IDs that need to be re-queued
+ */
+export async function deregisterWorker(workerId) {
+    if (!isRedisConfigured()) {
+        return { deregistered: false, unclaimedSessions: [] };
+    }
+    try {
+        const key = `${WORKER_PREFIX}${workerId}`;
+        const sessionsKey = `${key}${WORKER_SESSIONS_SUFFIX}`;
+        // Get sessions that need to be re-queued
+        const unclaimedSessions = await redisSMembers(sessionsKey);
+        // Delete worker registration and sessions set
+        await redisDel(key);
+        await redisDel(sessionsKey);
+        log.info('Worker deregistered', {
+            workerId,
+            unclaimedSessions: unclaimedSessions.length,
+        });
+        return {
+            deregistered: true,
+            unclaimedSessions,
+        };
+    }
+    catch (error) {
+        log.error('Failed to deregister worker', { error, workerId });
+        return { deregistered: false, unclaimedSessions: [] };
+    }
+}
+/**
+ * List all registered workers
+ */
+export async function listWorkers() {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const keys = await redisKeys(`${WORKER_PREFIX}*`);
+        // Filter out session keys
+        const workerKeys = keys.filter((k) => !k.endsWith(WORKER_SESSIONS_SUFFIX));
+        const workers = [];
+        for (const key of workerKeys) {
+            const worker = await redisGet(key);
+            if (worker) {
+                const sessionsKey = `${key}${WORKER_SESSIONS_SUFFIX}`;
+                const activeSessions = await redisSMembers(sessionsKey);
+                // Check if worker is stale
+                const isStale = Date.now() - worker.lastHeartbeat > HEARTBEAT_TIMEOUT;
+                const status = isStale ? 'offline' : worker.status;
+                workers.push({
+                    ...worker,
+                    status,
+                    activeSessions,
+                });
+            }
+        }
+        return workers;
+    }
+    catch (error) {
+        log.error('Failed to list workers', { error });
+        return [];
+    }
+}
+/**
+ * Get workers that have missed heartbeats (stale workers)
+ */
+export async function getStaleWorkers() {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    try {
+        const workers = await listWorkers();
+        return workers.filter((w) => w.status === 'offline');
+    }
+    catch (error) {
+        log.error('Failed to get stale workers', { error });
+        return [];
+    }
+}
+/**
+ * Add a session to a worker's active sessions
+ *
+ * @param workerId - Worker ID
+ * @param sessionId - Session ID being processed
+ */
+export async function addWorkerSession(workerId, sessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    try {
+        const sessionsKey = `${WORKER_PREFIX}${workerId}${WORKER_SESSIONS_SUFFIX}`;
+        await redisSAdd(sessionsKey, sessionId);
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to add worker session', { error, workerId, sessionId });
+        return false;
+    }
+}
+/**
+ * Remove a session from a worker's active sessions
+ *
+ * @param workerId - Worker ID
+ * @param sessionId - Session ID to remove
+ */
+export async function removeWorkerSession(workerId, sessionId) {
+    if (!isRedisConfigured()) {
+        return false;
+    }
+    try {
+        const sessionsKey = `${WORKER_PREFIX}${workerId}${WORKER_SESSIONS_SUFFIX}`;
+        await redisSRem(sessionsKey, sessionId);
+        return true;
+    }
+    catch (error) {
+        log.error('Failed to remove worker session', { error, workerId, sessionId });
+        return false;
+    }
+}
+/**
+ * Get total capacity across all active workers
+ */
+export async function getTotalCapacity() {
+    if (!isRedisConfigured()) {
+        return { totalCapacity: 0, totalActive: 0, availableCapacity: 0 };
+    }
+    try {
+        const workers = await listWorkers();
+        const activeWorkers = workers.filter((w) => w.status === 'active');
+        const totalCapacity = activeWorkers.reduce((sum, w) => sum + w.capacity, 0);
+        const totalActive = activeWorkers.reduce((sum, w) => sum + w.activeCount, 0);
+        return {
+            totalCapacity,
+            totalActive,
+            availableCapacity: totalCapacity - totalActive,
+        };
+    }
+    catch (error) {
+        log.error('Failed to get total capacity', { error });
+        return { totalCapacity: 0, totalActive: 0, availableCapacity: 0 };
+    }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@supaku/agentfactory-server",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Webhook server and distributed worker pool for AgentFactory — Redis queues, issue locks, session management",
+  "author": "Supaku (https://supaku.com)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/supaku/agentfactory",
+    "directory": "packages/server"
+  },
+  "homepage": "https://github.com/supaku/agentfactory/tree/main/packages/server",
+  "bugs": {
+    "url": "https://github.com/supaku/agentfactory/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "webhook",
+    "worker-pool",
+    "redis",
+    "agent-server",
+    "distributed"
+  ],
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "ioredis": "^5.4.2",
+    "@supaku/agentfactory": "0.1.0",
+    "@supaku/agentfactory-linear": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.4",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  }
+}