dank-ai 1.0.34 → 1.0.36

package/docker/entrypoint.js

@@ -2,7 +2,7 @@
 
 /**
  * Dank Agent Container Entrypoint
- *
+ * 
  * This script runs inside each agent container and handles:
  * - Loading agent code from the drop-off directory
  * - Setting up the LLM client
@@ -15,6 +15,10 @@ const path = require("path");
 const express = require("express");
 const winston = require("winston");
 const { v4: uuidv4 } = require("uuid");
+const os = require("os");
+const { EventEmitter } = require("events");
+const http = require("http");
+const { WebSocketServer } = require("ws");
 
 // Load environment variables
 require("dotenv").config();
@@ -37,6 +41,148 @@ const logger = winston.createLogger({
   ],
 });
 
+/**
+ * Log Buffer Service - Captures and stores stdout/stderr logs in memory
+ */
+class LogBufferService extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.maxSize = options.maxSize || 10000; // Max 10k log entries
+    this.maxAge = options.maxAge || 24 * 60 * 60 * 1000; // 24 hours
+    this.logs = []; // Circular buffer
+    this.isCapturing = false;
+    this.originalStdoutWrite = null;
+    this.originalStderrWrite = null;
+  }
+
+  /**
+   * Start capturing stdout/stderr from main process
+   */
+  start() {
+    if (this.isCapturing) return;
+
+    // Capture stdout
+    this.originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (chunk, encoding, callback) => {
+      this.addLog('stdout', chunk.toString());
+      return this.originalStdoutWrite(chunk, encoding, callback);
+    };
+
+    // Capture stderr
+    this.originalStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stderr.write = (chunk, encoding, callback) => {
+      this.addLog('stderr', chunk.toString());
+      return this.originalStderrWrite(chunk, encoding, callback);
+    };
+
+    this.isCapturing = true;
+    logger.info('✅ Log buffer service started');
+  }
+
+  /**
+   * Add log entry to buffer
+   */
+  addLog(stream, message) {
+    const now = Date.now();
+    const entry = {
+      timestamp: now,
+      stream, // 'stdout' or 'stderr'
+      message: message.trim(),
+    };
+
+    // Add to buffer
+    this.logs.push(entry);
+
+    // Trim to max size (circular buffer)
+    if (this.logs.length > this.maxSize) {
+      this.logs.shift(); // Remove oldest
+    }
+
+    // Emit for real-time streaming (if needed in future)
+    this.emit('log', entry);
+
+    // Cleanup old logs periodically
+    if (this.logs.length % 100 === 0) {
+      this.cleanup();
+    }
+  }
+
+  /**
+   * Remove logs older than maxAge
+   */
+  cleanup() {
+    const now = Date.now();
+    const cutoff = now - this.maxAge;
+    
+    // Remove old logs
+    while (this.logs.length > 0 && this.logs[0].timestamp < cutoff) {
+      this.logs.shift();
+    }
+  }
+
+  /**
+   * Get logs with filters
+   */
+  getLogs(options = {}) {
+    const {
+      startTime = null,
+      endTime = null,
+      limit = 100,
+      offset = 0,
+      stream = null, // 'stdout', 'stderr', or null for both
+    } = options;
+
+    let filtered = [...this.logs];
+
+    // Filter by time range
+    if (startTime) {
+      filtered = filtered.filter(log => log.timestamp >= startTime);
+    }
+    if (endTime) {
+      filtered = filtered.filter(log => log.timestamp <= endTime);
+    }
+
+    // Filter by stream
+    if (stream) {
+      filtered = filtered.filter(log => log.stream === stream);
+    }
+
+    // Sort by timestamp (oldest first)
+    filtered.sort((a, b) => a.timestamp - b.timestamp);
+
+    // Pagination
+    const total = filtered.length;
+    const paginated = filtered.slice(offset, offset + limit);
+
+    return {
+      logs: paginated,
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total,
+    };
+  }
+
+  /**
+   * Get logs from time range (e.g., "last 10 minutes")
+   */
+  getLogsByTimeRange(startTime, endTime) {
+    return this.getLogs({
+      startTime,
+      endTime,
+      limit: 10000, // Get all in range
+    });
+  }
+
+  /**
+   * Clear all logs
+   */
+  clear() {
+    this.logs = [];
+    this.emit('clear');
+  }
+}
+
 class AgentRuntime {
   constructor() {
     this.agentName = process.env.AGENT_NAME || "unknown";
@@ -45,13 +191,24 @@ class AgentRuntime {
     this.llmModel = process.env.LLM_MODEL || "gpt-3.5-turbo";
     this.agentPrompt =
       process.env.AGENT_PROMPT || "You are a helpful AI assistant.";
-
+    
     this.llmClient = null;
     this.agentCode = null;
     this.handlers = new Map();
     this.isRunning = false;
     this.startTime = new Date();
-
+    
+    // CPU usage tracking for metrics endpoint
+    // Track cumulative CPU usage since startup
+    this.cpuUsageStart = process.cpuUsage();
+    this.cpuUsageStartTime = process.hrtime.bigint();
+
+    // Initialize log buffer service
+    this.logBuffer = new LogBufferService({
+      maxSize: 10000, // 10k log entries
+      maxAge: 24 * 60 * 60 * 1000, // 24 hours
+    });
+    
     // HTTP server configuration
     this.httpEnabled = process.env.HTTP_ENABLED === "true";
     this.httpPort = parseInt(process.env.HTTP_PORT) || 3000;
@@ -66,8 +223,15 @@ class AgentRuntime {
     this.mainApp.use(express.json({ limit: "10mb" }));
     this.mainApp.use(express.urlencoded({ extended: true, limit: "10mb" }));
 
+    // HTTP server and WebSocket server (for log streaming)
+    this.httpServer = null;
+    this.wss = null;
+
     // Setup health endpoints on main app
     this.setupHealthEndpoints();
+    
+    // Setup log endpoints on main app
+    this.setupLogEndpoints();
   }
 
   /**
@@ -77,15 +241,18 @@ class AgentRuntime {
     try {
       logger.info(`Initializing agent: ${this.agentName} (${this.agentId})`);
 
+      // Start log buffer service to capture logs
+      this.logBuffer.start();
+      
       // Load agent code
       await this.loadAgentCode();
-
+      
       // Initialize LLM client
       await this.initializeLLM();
-
+      
       // Setup agent handlers
       await this.setupHandlers();
-
+      
       // Setup HTTP middleware (CORS, rate limiting) if HTTP is enabled
       // This must be done BEFORE routes are added
       if (this.httpEnabled) {
@@ -104,12 +271,12 @@ class AgentRuntime {
 
       // Start the main server (handles health, prompting, and user routes)
       this.startMainServer();
-
+      
       // Mark as running
       this.isRunning = true;
-
+      
       logger.info(`Agent ${this.agentName} initialized successfully`);
-
+      
       // Execute agent main function if it exists
       if (this.agentCode && typeof this.agentCode.main === "function") {
         // Create agent context with tools and capabilities
@@ -123,12 +290,12 @@ class AgentRuntime {
             prompt: this.agentPrompt,
           },
         };
-
+        
         // Execute main function without awaiting to prevent blocking
         // This allows the agent to run asynchronously while keeping the container alive
         this.executeAgentMain(agentContext);
       }
-
+      
       // Keep the container alive - this is essential for agent runtime
       this.keepAlive();
     } catch (error) {
@@ -143,10 +310,10 @@ class AgentRuntime {
   async executeAgentMain(agentContext) {
     try {
       logger.info("Executing agent main function...");
-
+      
       // Call the main function and handle different return patterns
       const result = this.agentCode.main(agentContext);
-
+      
       // If it returns a promise, handle it properly
       if (result && typeof result.then === "function") {
         result.catch((error) => {
@@ -161,7 +328,7 @@ class AgentRuntime {
           });
         });
       }
-
+      
       logger.info("Agent main function started successfully");
     } catch (error) {
       logger.error("Failed to execute agent main function:", error);
@@ -181,17 +348,11 @@ class AgentRuntime {
    */
   keepAlive() {
     logger.info("Starting keep-alive mechanism...");
-
+    
     // Set up a heartbeat interval to keep the container running
     this.heartbeatInterval = setInterval(() => {
       if (this.isRunning) {
-        logger.debug(
-          `Agent ${this.agentName} heartbeat - uptime: ${Math.floor(
-            process.uptime()
-          )}s`
-        );
-
-        // Trigger heartbeat handlers
+        // Trigger heartbeat handlers (user-defined handlers only, no default logging)
         const heartbeatHandlers = this.handlers.get("heartbeat") || [];
         heartbeatHandlers.forEach((handler) => {
           try {
@@ -202,14 +363,14 @@ class AgentRuntime {
         });
       }
     }, 30000); // Heartbeat every 30 seconds
-
+    
     // Also set up a simple keep-alive mechanism
     // This ensures the event loop stays active
     this.keepAliveTimeout = setTimeout(() => {
       // This timeout will never fire, but keeps the event loop active
       logger.debug("Keep-alive timeout triggered (this should not happen)");
     }, 2147483647); // Maximum timeout value
-
+    
     logger.info("Keep-alive mechanism started - container will stay running");
   }
 
@@ -219,7 +380,7 @@ class AgentRuntime {
   async loadAgentCode() {
     const codeDir = "/app/agent-code";
     const mainFile = path.join(codeDir, "index.js");
-
+    
     if (fs.existsSync(mainFile)) {
       logger.info("Loading agent code from index.js");
       this.agentCode = require(mainFile);
@@ -231,7 +392,7 @@ class AgentRuntime {
           logger.info(
             "Basic mode agent is ready and will respond to HTTP requests if enabled"
           );
-
+          
           // In basic mode, the agent just stays alive and responds to HTTP requests
           // The keep-alive mechanism will handle keeping the container running
           return Promise.resolve();
@@ -306,22 +467,21 @@ class AgentRuntime {
       (error) => logger.error("Agent error:", error),
     ]);
 
-    this.handlers.set("heartbeat", [
-      () => logger.debug(`Agent ${this.agentName} heartbeat`),
-    ]);
+    // No default heartbeat handler - users can add their own if needed
+    this.handlers.set("heartbeat", []);
 
     // Load custom handlers from agent code
     if (this.agentCode && this.agentCode.handlers) {
       Object.entries(this.agentCode.handlers).forEach(
         ([event, handlerList]) => {
-          if (!this.handlers.has(event)) {
-            this.handlers.set(event, []);
-          }
-
+        if (!this.handlers.has(event)) {
+          this.handlers.set(event, []);
+        }
+        
           const handlers = Array.isArray(handlerList)
             ? handlerList
             : [handlerList];
-          this.handlers.get(event).push(...handlers);
+        this.handlers.get(event).push(...handlers);
         }
       );
     }
@@ -469,7 +629,7 @@ class AgentRuntime {
         http: {
           enabled: this.httpEnabled,
           port: this.httpEnabled ? this.httpPort : null,
-          routes: this.httpEnabled && this.mainApp ? this.getRoutesList() : [],
+          endpoints: this.mainApp ? this.getRoutesList() : { builtin: [], userDefined: [], all: [] },
         },
         handlers: Array.from(this.handlers.keys()),
         environment: {
@@ -479,6 +639,230 @@ class AgentRuntime {
         },
       });
     });
+
+    this.mainApp.get("/metrics", async (req, res) => {
+      const memUsage = process.memoryUsage();
+      
+      // Take a delta measurement for accurate CPU percentage
+      // Measure CPU usage over a period (500ms for better accuracy)
+      const measurementStart = process.cpuUsage();
+      const measurementStartTime = process.hrtime.bigint(); // High-resolution time in nanoseconds
+      
+      // Wait a period to measure CPU delta (longer period = more accurate)
+      await new Promise(resolve => setTimeout(resolve, 500));
+      
+      const measurementEnd = process.cpuUsage(measurementStart);
+      const measurementEndTime = process.hrtime.bigint();
+      
+      // Calculate elapsed time in milliseconds (hrtime is in nanoseconds)
+      const measurementDeltaNs = Number(measurementEndTime - measurementStartTime);
+      const measurementDeltaMs = measurementDeltaNs / 1000000; // Convert nanoseconds to milliseconds
+      
+      // Calculate CPU percentage from delta
+      // cpuUsage.user and cpuUsage.system are in microseconds
+      const totalCpuTimeMicroseconds = measurementEnd.user + measurementEnd.system;
+      const totalCpuTimeMilliseconds = totalCpuTimeMicroseconds / 1000;
+      
+      // CPU percentage = (CPU time used / elapsed time) * 100
+      // This gives us the percentage of one CPU core used
+      // For multi-core systems, values can exceed 100% if using multiple cores
+      const cpuPercent = measurementDeltaMs > 0 
+        ? (totalCpuTimeMilliseconds / measurementDeltaMs) * 100
+        : 0;
+      
+      // Calculate cumulative CPU usage since startup
+      const cumulativeCpuUsage = process.cpuUsage(this.cpuUsageStart);
+      const cumulativeCpuTimeMicroseconds = cumulativeCpuUsage.user + cumulativeCpuUsage.system;
+      const cumulativeCpuTimeMilliseconds = cumulativeCpuTimeMicroseconds / 1000;
+      const cumulativeTimeMs = Number(process.hrtime.bigint() - this.cpuUsageStartTime) / 1000000;
+      const cumulativeCpuPercent = cumulativeTimeMs > 0
+        ? (cumulativeCpuTimeMilliseconds / cumulativeTimeMs) * 100
+        : 0;
+      
+      // Get system memory info
+      const totalMemory = os.totalmem();
+      const freeMemory = os.freemem();
+      const usedMemory = totalMemory - freeMemory;
+      
+      res.json({
+        timestamp: new Date().toISOString(),
+        agent: {
+          name: this.agentName,
+          id: this.agentId,
+          uptime: Date.now() - this.startTime.getTime(),
+        },
+        cpu: {
+          current: {
+            user: measurementEnd.user, // microseconds (delta over measurement period)
+            system: measurementEnd.system, // microseconds (delta over measurement period)
+            total: totalCpuTimeMilliseconds, // milliseconds (delta over measurement period)
+            percent: parseFloat(cpuPercent.toFixed(2)), // percentage over measurement period
+            measurementPeriod: measurementDeltaMs, // milliseconds
+          },
+          cumulative: {
+            user: cumulativeCpuUsage.user, // microseconds (since startup)
+            system: cumulativeCpuUsage.system, // microseconds (since startup)
+            total: cumulativeCpuTimeMilliseconds, // milliseconds (since startup)
+            percent: parseFloat(cumulativeCpuPercent.toFixed(2)), // average percentage since startup
+            uptime: cumulativeTimeMs, // milliseconds since startup
+          },
+          cores: os.cpus().length,
+          model: os.cpus()[0]?.model || "unknown",
+        },
+        memory: {
+          process: {
+            rss: memUsage.rss, // Resident Set Size - total memory allocated
+            heapTotal: memUsage.heapTotal, // Total heap memory allocated
+            heapUsed: memUsage.heapUsed, // Heap memory used
+            external: memUsage.external, // Memory used by C++ objects bound to JS objects
+            arrayBuffers: memUsage.arrayBuffers, // Memory allocated for ArrayBuffers
+          },
+          system: {
+            total: totalMemory, // Total system memory
+            free: freeMemory, // Free system memory
+            used: usedMemory, // Used system memory
+            percent: ((usedMemory / totalMemory) * 100).toFixed(2), // Percentage used
+          },
+          // Human-readable formats
+          processFormatted: {
+            rss: `${(memUsage.rss / 1024 / 1024).toFixed(2)} MB`,
+            heapTotal: `${(memUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`,
+            heapUsed: `${(memUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`,
+            external: `${(memUsage.external / 1024 / 1024).toFixed(2)} MB`,
+          },
+          systemFormatted: {
+            total: `${(totalMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
+            free: `${(freeMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
+            used: `${(usedMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
+          },
+        },
+        loadAverage: os.loadavg(), // 1, 5, and 15 minute load averages
+      });
+    });
+  }
+
+  /**
+   * Setup log endpoints on main app
+   */
+  setupLogEndpoints() {
+    /**
+     * GET /logs
+     * Get historical logs with pagination and time filtering
+     * 
+     * Query params:
+     * - startTime: Unix timestamp (ms) - start of time range
+     * - endTime: Unix timestamp (ms) - end of time range
+     * - limit: Number of logs per page (default: 100)
+     * - offset: Pagination offset (default: 0)
+     * - stream: 'stdout' | 'stderr' | null (default: both)
+     */
+    this.mainApp.get("/logs", (req, res) => {
+      try {
+        const {
+          startTime,
+          endTime,
+          limit = 100,
+          offset = 0,
+          stream,
+        } = req.query;
+
+        const options = {
+          startTime: startTime ? parseInt(startTime) : null,
+          endTime: endTime ? parseInt(endTime) : null,
+          limit: parseInt(limit),
+          offset: parseInt(offset),
+          stream: stream || null,
+        };
+
+        const result = this.logBuffer.getLogs(options);
+
+        res.json({
+          success: true,
+          data: result,
+        });
+      } catch (error) {
+        logger.error('Error getting logs:', error);
+        res.status(500).json({
+          success: false,
+          error: 'Failed to get logs',
+          message: error.message,
+        });
+      }
+    });
+
+    /**
+     * GET /logs/range
+     * Get logs from specific time range (convenience endpoint)
+     * 
+     * Query params:
+     * - minutesAgo: Number of minutes to look back (default: 10)
+     * - stream: 'stdout' | 'stderr' | null
+     */
+    this.mainApp.get("/logs/range", (req, res) => {
+      try {
+        const { minutesAgo = 10, stream } = req.query;
+        const endTime = Date.now();
+        const startTime = endTime - (parseInt(minutesAgo) * 60 * 1000);
+
+        const result = this.logBuffer.getLogsByTimeRange(startTime, endTime);
+
+        // Filter by stream if specified
+        let logs = result.logs;
+        if (stream) {
+          logs = logs.filter(log => log.stream === stream);
+        }
+
+        res.json({
+          success: true,
+          data: {
+            logs,
+            count: logs.length,
+            startTime,
+            endTime,
+          },
+        });
+      } catch (error) {
+        logger.error('Error getting logs by range:', error);
+        res.status(500).json({
+          success: false,
+          error: 'Failed to get logs',
+          message: error.message,
+        });
+      }
+    });
+
+    /**
+     * GET /logs/stats
+     * Get log statistics
+     */
+    this.mainApp.get("/logs/stats", (req, res) => {
+      try {
+        const allLogs = this.logBuffer.getLogs({ limit: 10000 });
+        
+        const stats = {
+          total: allLogs.total,
+          oldest: allLogs.logs[0]?.timestamp || null,
+          newest: allLogs.logs[allLogs.logs.length - 1]?.timestamp || null,
+          stdout: allLogs.logs.filter(l => l.stream === 'stdout').length,
+          stderr: allLogs.logs.filter(l => l.stream === 'stderr').length,
+          bufferSize: this.logBuffer.logs.length,
+          maxSize: this.logBuffer.maxSize,
+          maxAge: this.logBuffer.maxAge,
+        };
+
+        res.json({
+          success: true,
+          data: stats,
+        });
+      } catch (error) {
+        logger.error('Error getting log stats:', error);
+        res.status(500).json({
+          success: false,
+          error: 'Failed to get log stats',
+          message: error.message,
+        });
+      }
+    });
   }
 
   /**
@@ -531,14 +915,14 @@ class AgentRuntime {
     if (!this.agentCode || !this.agentCode.routes) {
       // Set up default root route only (404 handler will be set up later)
       this.mainApp.get("/", (req, res) => {
-        res.json({
-          message: `🤖 ${this.agentName} HTTP Server`,
-          agent: this.agentName,
+      res.json({
+        message: `🤖 ${this.agentName} HTTP Server`,
+        agent: this.agentName,
           version: "1.0.0",
-          endpoints: this.getRoutesList(),
+        endpoints: this.getRoutesList(),
           timestamp: new Date().toISOString(),
-        });
       });
+    });
       return;
     }
 
@@ -592,7 +976,7 @@ class AgentRuntime {
       res.status(404).json({
         error: "Not Found",
         message: `Cannot ${req.method} ${req.path}`,
-        availableRoutes: this.getRoutesList(),
+        availableEndpoints: this.getRoutesList(),
       });
     });
 
@@ -610,23 +994,131 @@ class AgentRuntime {
   }
 
   /**
-   * Get list of registered routes
+   * Get list of registered routes, categorized as built-in or user-defined
    */
   getRoutesList() {
-    if (!this.mainApp) return [];
-
-    const routes = [];
+    if (!this.mainApp) return { builtin: [], userDefined: [], all: [] };
+    
+    // List of built-in endpoints
+    const builtInPaths = [
+      '/health',
+      '/status',
+      '/metrics',
+      '/logs',
+      '/logs/range',
+      '/logs/stats',
+      '/prompt',
+      '/'
+    ];
+    
+    const builtin = [];
+    const userDefined = [];
+    
+    // Add WebSocket endpoint manually (it won't appear in router stack)
+    if (this.wss) {
+      builtin.push({
+        path: '/logs/stream',
+        methods: ['WS'],
+        type: 'websocket'
+      });
+    }
+    
     this.mainApp._router.stack.forEach((middleware) => {
       if (middleware.route) {
-        const methods = Object.keys(middleware.route.methods);
-        routes.push({
-          path: middleware.route.path,
-          methods: methods.map((m) => m.toUpperCase()),
-        });
+        const path = middleware.route.path;
+        const methods = Object.keys(middleware.route.methods).map((m) => m.toUpperCase());
+        const routeInfo = {
+          path: path,
+          methods: methods,
+          type: 'http'
+        };
+        
+        // Check if it's a built-in endpoint
+        if (builtInPaths.includes(path)) {
+          builtin.push(routeInfo);
+        } else {
+          userDefined.push(routeInfo);
+        }
       }
     });
+    
+    return {
+      builtin: builtin,
+      userDefined: userDefined,
+      all: [...builtin, ...userDefined]
+    };
+  }
+
+  /**
+   * Setup WebSocket server for log streaming on /logs/stream
+   */
+  setupLogStreaming() {
+    if (!this.httpServer) {
+      logger.warn('HTTP server not initialized, cannot setup WebSocket');
+      return;
+    }
+
+    this.wss = new WebSocketServer({
+      server: this.httpServer,
+      path: '/logs/stream',
+    });
+
+    this.wss.on('connection', (ws, req) => {
+      logger.info('📡 Log stream WebSocket connected');
 
-    return routes;
+      // Send recent logs immediately (last 100)
+      const recentLogs = this.logBuffer.getLogs({ limit: 100 });
+      if (ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify({
+          type: 'initial',
+          data: recentLogs.logs,
+        }));
+      }
+
+      // Listen for new logs
+      const onLog = (logEntry) => {
+        if (ws.readyState === ws.OPEN) {
+          ws.send(JSON.stringify({
+            type: 'log',
+            data: logEntry,
+          }));
+        }
+      };
+
+      this.logBuffer.on('log', onLog);
+
+      // Cleanup on disconnect
+      ws.on('close', () => {
+        this.logBuffer.off('log', onLog);
+        logger.info('📡 Log stream WebSocket disconnected');
+      });
+
+      // Handle ping/pong for keepalive
+      ws.on('pong', () => {
+        ws.isAlive = true;
+      });
+
+      // Mark as alive initially
+      ws.isAlive = true;
+    });
+
+    // Keepalive ping every 30 seconds
+    const keepaliveInterval = setInterval(() => {
+      if (!this.wss) {
+        clearInterval(keepaliveInterval);
+        return;
+      }
+      
+      this.wss.clients.forEach((ws) => {
+        if (ws.isAlive === false) {
+          return ws.terminate();
+        }
+        ws.isAlive = false;
+        ws.ping();
+      });
+    }, 30000);
+
+    logger.info('✅ Log streaming WebSocket server started on /logs/stream');
   }
 
   /**
@@ -637,10 +1129,20 @@ class AgentRuntime {
     const port = this.mainPort;
     const host = "0.0.0.0";
 
-    this.mainApp.listen(port, host, () => {
+    // Create HTTP server from Express app (needed for WebSocket support)
+    this.httpServer = http.createServer(this.mainApp);
+
+    // Setup WebSocket for log streaming
+    this.setupLogStreaming();
+
+    // Start the HTTP server
+    this.httpServer.listen(port, host, () => {
       logger.info(`🌐 Main HTTP server listening on ${host}:${port}`);
       logger.info(`🔗 Health check: GET http://localhost:${port}/health`);
       logger.info(`🔗 Status: GET http://localhost:${port}/status`);
+      logger.info(`🔗 Metrics: GET http://localhost:${port}/metrics`);
+      logger.info(`📋 Logs: GET http://localhost:${port}/logs`);
+      logger.info(`📡 Log stream: WSS ws://localhost:${port}/logs/stream`);
       
       const directPromptingEnabled =
         process.env.DIRECT_PROMPTING_ENABLED !== "false";
@@ -859,7 +1361,7 @@ class AgentRuntime {
             data: params.data,
             timeout: params.timeout || 10000,
           });
-
+          
           return {
             status: response.status,
             headers: response.headers,
@@ -870,11 +1372,11 @@ class AgentRuntime {
           throw new Error(`HTTP request failed: ${error.message}`);
         }
       },
-
+      
       getCurrentTime: (params = {}) => {
         const now = new Date();
         const format = params.format || "iso";
-
+        
         switch (format) {
           case "iso":
             return {
@@ -898,14 +1400,14 @@ class AgentRuntime {
             };
         }
       },
-
+      
       analyzeText: (params) => {
         const text = params.text;
         const words = text.split(/\s+/).filter((word) => word.length > 0);
         const sentences = text
           .split(/[.!?]+/)
           .filter((s) => s.trim().length > 0);
-
+        
         const result = {
           length: text.length,
           stats: {
@@ -918,7 +1420,7 @@ class AgentRuntime {
                 : 0,
           },
         };
-
+        
         if (params.includeSentiment) {
           const positiveWords = [
             "good",
@@ -934,7 +1436,7 @@ class AgentRuntime {
             "horrible",
             "disappointing",
           ];
-
+          
           const lowerText = text.toLowerCase();
           const positiveCount = positiveWords.filter((word) =>
             lowerText.includes(word)
@@ -942,7 +1444,7 @@ class AgentRuntime {
           const negativeCount = negativeWords.filter((word) =>
             lowerText.includes(word)
           ).length;
-
+          
           result.sentiment = {
             score: positiveCount - negativeCount,
             label:
@@ -953,7 +1455,7 @@ class AgentRuntime {
                 : "neutral",
           };
         }
-
+        
         return result;
       },
     };
@@ -964,20 +1466,19 @@ class AgentRuntime {
    */
   async shutdown() {
     logger.info("Shutting down agent...");
-
+    
     this.isRunning = false;
-
+    
     // Clean up keep-alive mechanisms
     if (this.heartbeatInterval) {
       clearInterval(this.heartbeatInterval);
-      logger.debug("Heartbeat interval cleared");
     }
-
+    
     if (this.keepAliveTimeout) {
       clearTimeout(this.keepAliveTimeout);
       logger.debug("Keep-alive timeout cleared");
     }
-
+    
     // Call shutdown handlers if they exist
     const shutdownHandlers = this.handlers.get("shutdown") || [];
     for (const handler of shutdownHandlers) {
@@ -987,7 +1488,7 @@ class AgentRuntime {
         logger.error("Error in shutdown handler:", error);
       }
     }
-
+    
     logger.info("Agent shutdown complete");
     process.exit(0);
   }