agentdev-webui 1.0.0

package/lib/redis-logs.js

@@ -0,0 +1,226 @@
+const Redis = require('ioredis');
+const config = require('./config');
+
+// Two Redis clients: one for pub/sub, one for regular commands
+let pubClient = null;
+let subClient = null;
+let subscribers = new Map(); // channel -> Set of callback functions
+
+function connect() {
+  if (pubClient && subClient) {
+    return { pubClient, subClient };
+  }
+
+  const redisConfig = {
+    host: config.REDIS_HOST || 'localhost',
+    port: config.REDIS_PORT || 6379,
+    db: config.REDIS_DB || 3,
+    retryStrategy: (times) => {
+      const delay = Math.min(times * 50, 2000);
+      return delay;
+    }
+  };
+
+  pubClient = new Redis(redisConfig);
+  subClient = new Redis(redisConfig);
+
+  pubClient.on('error', (err) => console.error('Redis Pub Client Error:', err));
+  subClient.on('error', (err) => console.error('Redis Sub Client Error:', err));
+
+  // Handle incoming messages
+  subClient.on('message', (channel, message) => {
+    const callbacks = subscribers.get(channel);
+    if (callbacks) {
+      try {
+        const data = JSON.parse(message);
+        callbacks.forEach(cb => cb(data));
+      } catch (e) {
+        console.error('Error parsing Redis message:', e);
+      }
+    }
+  });
+
+  // Handle pattern messages (for wildcard subscriptions)
+  subClient.on('pmessage', (pattern, channel, message) => {
+    const callbacks = subscribers.get(pattern);
+    if (callbacks) {
+      try {
+        const data = JSON.parse(message);
+        // Extract agentId from channel (agentdev:logs:{agentId})
+        const agentId = data.agent || channel.replace('agentdev:logs:', '');
+        callbacks.forEach(cb => cb(agentId, data));
+      } catch (e) {
+        console.error('Error parsing Redis pmessage:', e);
+      }
+    }
+  });
+
+  return { pubClient, subClient };
+}
+
+/**
+ * Publish a log message to Redis channel
+ * @param {string} agentId - Agent identifier
+ * @param {object} logData - Log data { content, level, timestamp }
+ */
+async function publishLog(agentId, logData) {
+  const { pubClient } = connect();
+  const channel = `agentdev:logs:${agentId}`;
+  const message = JSON.stringify({
+    agent: agentId,
+    timestamp: logData.timestamp || new Date().toISOString(),
+    level: logData.level || 'INFO',
+    content: logData.content
+  });
+
+  await pubClient.publish(channel, message);
+}
+
+/**
+ * Subscribe to agent logs
+ * @param {string} agentId - Agent identifier (or '*' for all agents)
+ * @param {function} callback - Callback function(data, channel)
+ */
+async function subscribeToLogs(agentId, callback) {
+  const { subClient } = connect();
+
+  if (agentId === '*') {
+    // Subscribe to all agent logs with pattern
+    const pattern = 'agentdev:logs:*';
+    if (!subscribers.has(pattern)) {
+      subscribers.set(pattern, new Set());
+      await subClient.psubscribe(pattern);
+    }
+    subscribers.get(pattern).add(callback);
+    return pattern;
+  } else {
+    // Subscribe to specific agent
+    const channel = `agentdev:logs:${agentId}`;
+    if (!subscribers.has(channel)) {
+      subscribers.set(channel, new Set());
+      await subClient.subscribe(channel);
+    }
+    subscribers.get(channel).add(callback);
+    return channel;
+  }
+}
+
+/**
+ * Unsubscribe from agent logs
+ * @param {string} channelOrPattern - Channel or pattern returned from subscribeToLogs
+ * @param {function} callback - Callback function to remove
+ */
+async function unsubscribeFromLogs(channelOrPattern, callback) {
+  const { subClient } = connect();
+  const callbacks = subscribers.get(channelOrPattern);
+
+  if (callbacks) {
+    callbacks.delete(callback);
+
+    // If no more callbacks, unsubscribe from channel
+    if (callbacks.size === 0) {
+      subscribers.delete(channelOrPattern);
+      if (channelOrPattern.includes('*')) {
+        await subClient.punsubscribe(channelOrPattern);
+      } else {
+        await subClient.unsubscribe(channelOrPattern);
+      }
+    }
+  }
+}
+
+/**
+ * Publish agent status update
+ * @param {object} statusData - Status data { agents: [...], history: [...] }
+ */
+async function publishAgentStatus(statusData) {
+  const { pubClient } = connect();
+  const channel = 'agentdev:agents:status';
+  const message = JSON.stringify(statusData);
+  await pubClient.publish(channel, message);
+}
+
+/**
+ * Subscribe to agent status updates
+ * @param {function} callback - Callback function(data)
+ */
+async function subscribeToAgentStatus(callback) {
+  const { subClient } = connect();
+  const channel = 'agentdev:agents:status';
+
+  if (!subscribers.has(channel)) {
+    subscribers.set(channel, new Set());
+    await subClient.subscribe(channel);
+  }
+  subscribers.get(channel).add(callback);
+  return channel;
+}
+
+/**
+ * Store value in Redis with optional TTL
+ * @param {string} key - Redis key
+ * @param {string|object} value - Value to store (objects are JSON stringified)
+ * @param {number} ttl - Time to live in seconds (optional)
+ */
+async function set(key, value, ttl) {
+  const { pubClient } = connect();
+  const stringValue = typeof value === 'object' ? JSON.stringify(value) : value;
+
+  if (ttl) {
+    await pubClient.setex(key, ttl, stringValue);
+  } else {
+    await pubClient.set(key, stringValue);
+  }
+}
+
+/**
+ * Get value from Redis
+ * @param {string} key - Redis key
+ * @returns {string|object|null} - Value (auto-parsed if JSON)
+ */
+async function get(key) {
+  const { pubClient } = connect();
+  const value = await pubClient.get(key);
+
+  if (!value) return null;
+
+  // Try to parse as JSON
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return value;
+  }
+}
+
+/**
+ * Delete key from Redis
+ * @param {string} key - Redis key
+ */
+async function del(key) {
+  const { pubClient } = connect();
+  await pubClient.del(key);
+}
+
+/**
+ * Close Redis connections
+ */
+function disconnect() {
+  if (pubClient) pubClient.quit();
+  if (subClient) subClient.quit();
+  pubClient = null;
+  subClient = null;
+  subscribers.clear();
+}
+
+module.exports = {
+  connect,
+  disconnect,
+  publishLog,
+  subscribeToLogs,
+  unsubscribeFromLogs,
+  publishAgentStatus,
+  subscribeToAgentStatus,
+  set,
+  get,
+  del
+};