dank-ai 1.0.31 → 1.0.33

package/docker/entrypoint.js

@@ -56,11 +56,17 @@ class AgentRuntime {
     this.httpEnabled = process.env.HTTP_ENABLED === "true";
     this.httpPort = parseInt(process.env.HTTP_PORT) || 3000;
     this.httpHost = process.env.HTTP_HOST || "0.0.0.0";
+    
+    // Main agent port (used for health, prompting, and optionally HTTP API)
+    this.mainPort = parseInt(process.env.DOCKER_PORT) || 3000;
+    logger.info(`🔌 Main agent port configured: ${this.mainPort} (from DOCKER_PORT: ${process.env.DOCKER_PORT || 'default'})`);
 
-    // Setup express servers
-    this.healthApp = express(); // Health check server (always running)
-    this.httpApp = null; // Main HTTP server (optional)
+    // Single Express app for health, prompting, and HTTP API
+    this.mainApp = express();
+    this.mainApp.use(express.json({ limit: "10mb" }));
+    this.mainApp.use(express.urlencoded({ extended: true, limit: "10mb" }));
 
+    // Setup health endpoints on main app
     this.setupHealthEndpoints();
   }
 
@@ -80,18 +86,25 @@ class AgentRuntime {
       // Setup agent handlers
       await this.setupHandlers();
 
-      // Start health check server
-      this.startHealthServer();
-
-      // Start HTTP server if enabled
+      // Setup HTTP middleware (CORS, rate limiting) if HTTP is enabled
+      // This must be done BEFORE routes are added
       if (this.httpEnabled) {
-        await this.setupHttpServer();
-        this.startHttpServer();
+        await this.setupHttpMiddleware();
       }
 
-      // Setup direct prompting server
+      // Setup user routes on main app (if any routes exist in agent code)
+      // Routes are always added to the main app (same server as health and prompting)
+      await this.setupAgentRoutes();
+
+      // Setup direct prompting server (adds /prompt endpoint to main app)
       await this.setupDirectPromptingServer();
 
+      // Set up 404 and error handlers AFTER all routes (including /prompt) are registered
+      this.setupDefaultRoutes();
+
+      // Start the main server (handles health, prompting, and user routes)
+      this.startMainServer();
+
       // Mark as running
       this.isRunning = true;
 
@@ -418,10 +431,10 @@ class AgentRuntime {
   }
 
   /**
-   * Setup health check endpoints
+   * Setup health check endpoints on main app
    */
   setupHealthEndpoints() {
-    this.healthApp.get("/health", (req, res) => {
+    this.mainApp.get("/health", (req, res) => {
       res.json({
         status: this.isRunning ? "healthy" : "starting",
         agent: {
@@ -439,7 +452,7 @@ class AgentRuntime {
       });
     });
 
-    this.healthApp.get("/status", (req, res) => {
+    this.mainApp.get("/status", (req, res) => {
       res.json({
         agent: {
           name: this.agentName,
@@ -456,7 +469,7 @@ class AgentRuntime {
         http: {
           enabled: this.httpEnabled,
           port: this.httpEnabled ? this.httpPort : null,
-          routes: this.httpEnabled && this.httpApp ? this.getRoutesList() : [],
+          routes: this.httpEnabled && this.mainApp ? this.getRoutesList() : [],
         },
         handlers: Array.from(this.handlers.keys()),
         environment: {
@@ -469,22 +482,15 @@ class AgentRuntime {
   }
 
   /**
-   * Setup HTTP server with Express.js
+   * Setup HTTP middleware (CORS, rate limiting) on main app
+   * This is only called if HTTP is explicitly enabled via configuration
    */
-  async setupHttpServer() {
-    if (!this.httpEnabled) return;
-
-    logger.info(`Setting up HTTP server on port ${this.httpPort}`);
-
-    this.httpApp = express();
-
-    // Basic middleware
-    this.httpApp.use(express.json({ limit: "10mb" }));
-    this.httpApp.use(express.urlencoded({ extended: true, limit: "10mb" }));
+  async setupHttpMiddleware() {
+    logger.info(`Setting up HTTP middleware on main server`);
 
     // CORS if enabled
     if (process.env.HTTP_CORS !== "false") {
-      this.httpApp.use((req, res, next) => {
+      this.mainApp.use((req, res, next) => {
         res.header("Access-Control-Allow-Origin", "*");
         res.header(
           "Access-Control-Allow-Methods",
@@ -512,50 +518,31 @@ class AgentRuntime {
         max: parseInt(process.env.HTTP_RATE_LIMIT_MAX) || 100,
         message: process.env.HTTP_RATE_LIMIT_MESSAGE || "Too many requests",
       });
-      this.httpApp.use(limiter);
+      this.mainApp.use(limiter);
     }
-
-    // Setup routes from agent configuration
-    await this.setupAgentRoutes();
-
-    // Default routes
-    this.httpApp.get("/", (req, res) => {
-      res.json({
-        message: `🤖 ${this.agentName} HTTP Server`,
-        agent: this.agentName,
-        version: "1.0.0",
-        endpoints: this.getRoutesList(),
-        timestamp: new Date().toISOString(),
-      });
-    });
-
-    // 404 handler
-    this.httpApp.use((req, res) => {
-      res.status(404).json({
-        error: "Not Found",
-        message: `Cannot ${req.method} ${req.path}`,
-        availableRoutes: this.getRoutesList(),
-      });
-    });
-
-    // Error handler
-    this.httpApp.use((err, req, res, next) => {
-      logger.error("HTTP server error:", err);
-      res.status(500).json({
-        error: "Internal Server Error",
-        message:
-          process.env.NODE_ENV === "development"
-            ? err.message
-            : "Something went wrong",
-      });
-    });
   }
 
   /**
    * Setup routes defined in agent configuration
+   * Routes are always added to the main app (same server as health and prompting)
+   * NOTE: Does NOT set up 404 handler - that must be done AFTER all routes including /prompt
    */
   async setupAgentRoutes() {
-    if (!this.agentCode || !this.agentCode.routes) return;
+    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,
+          version: "1.0.0",
+          endpoints: this.getRoutesList(),
+          timestamp: new Date().toISOString(),
+        });
+      });
+      return;
+    }
+
+    logger.info(`Setting up user routes on main server`);
 
     // Setup routes from agent code
     Object.entries(this.agentCode.routes).forEach(([path, handlers]) => {
@@ -563,14 +550,9 @@ class AgentRuntime {
         Object.entries(handlers).forEach(([method, handler]) => {
           if (typeof handler === "function") {
             const lowerMethod = method.toLowerCase();
-            if (this.httpApp[lowerMethod]) {
-              // Wrap handler to emit tool events
-              const wrappedHandler = this.wrapHttpHandlerWithEvents(
-                method,
-                path,
-                handler
-              );
-              this.httpApp[lowerMethod](path, wrappedHandler);
+            if (this.mainApp[lowerMethod]) {
+              // Register route handler directly on main app
+              this.mainApp[lowerMethod](path, handler);
               logger.info(`Registered route: ${method.toUpperCase()} ${path}`);
             }
           }
@@ -582,21 +564,59 @@ class AgentRuntime {
     if (this.agentCode.middleware && Array.isArray(this.agentCode.middleware)) {
       this.agentCode.middleware.forEach((middleware) => {
         if (typeof middleware === "function") {
-          this.httpApp.use(middleware);
+          this.mainApp.use(middleware);
           logger.info("Registered custom middleware");
         }
       });
     }
+
+    // Set up default root route (404 handler will be set up later, after /prompt)
+    this.mainApp.get("/", (req, res) => {
+      res.json({
+        message: `🤖 ${this.agentName} HTTP Server`,
+        agent: this.agentName,
+        version: "1.0.0",
+        endpoints: this.getRoutesList(),
+        timestamp: new Date().toISOString(),
+      });
+    });
+  }
+
+  /**
+   * Setup 404 and error handlers on main app
+   * MUST be called AFTER all routes (including /prompt) are registered
+   */
+  setupDefaultRoutes() {
+    // 404 handler (must be after ALL routes, including /prompt)
+    this.mainApp.use((req, res) => {
+      res.status(404).json({
+        error: "Not Found",
+        message: `Cannot ${req.method} ${req.path}`,
+        availableRoutes: this.getRoutesList(),
+      });
+    });
+
+    // Error handler (must be last)
+    this.mainApp.use((err, req, res, next) => {
+      logger.error("HTTP server error:", err);
+      res.status(500).json({
+        error: "Internal Server Error",
+        message:
+          process.env.NODE_ENV === "development"
+            ? err.message
+            : "Something went wrong",
+      });
+    });
   }
 
   /**
    * Get list of registered routes
    */
   getRoutesList() {
-    if (!this.httpApp) return [];
+    if (!this.mainApp) return [];
 
     const routes = [];
-    this.httpApp._router.stack.forEach((middleware) => {
+    this.mainApp._router.stack.forEach((middleware) => {
       if (middleware.route) {
         const methods = Object.keys(middleware.route.methods);
         routes.push({
@@ -610,167 +630,66 @@ class AgentRuntime {
   }
 
   /**
-   * Start health check server
+   * Start main server (handles health, prompting, and optionally HTTP API)
+   * The main server ALWAYS runs on the port specified by setPromptingServer (or default 3000)
    */
-  startHealthServer() {
-    const port = process.env.HEALTH_PORT || 3001;
-
-    this.healthApp.listen(port, "0.0.0.0", () => {
-      logger.info(`Health server listening on port ${port}`);
-    });
-  }
-
-  /**
-   * Start HTTP server
-   */
-  startHttpServer() {
-    if (!this.httpEnabled || !this.httpApp) return;
-
-    this.httpApp.listen(this.httpPort, this.httpHost, () => {
-      logger.info(
-        `🌐 HTTP server listening on ${this.httpHost}:${this.httpPort}`
-      );
-      logger.info(
-        `🔗 Agent HTTP endpoint: http://${this.httpHost}:${this.httpPort}`
-      );
+  startMainServer() {
+    const port = this.mainPort;
+    const host = "0.0.0.0";
+
+    this.mainApp.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`);
+      
+      const directPromptingEnabled =
+        process.env.DIRECT_PROMPTING_ENABLED !== "false";
+      if (directPromptingEnabled) {
+        logger.info(`📡 Direct prompting: POST http://localhost:${port}/prompt`);
+      }
+      
+      if (this.httpEnabled) {
+        logger.info(`🔗 HTTP API routes: http://localhost:${port}`);
+      }
+      
+      logger.info(`✅ Main server ready on port ${port}`);
     });
   }
 
   /**
-   * Setup direct prompting server (WebSocket/HTTP)
+   * Setup direct prompting server (HTTP only)
+   * Always sets up /prompt endpoint - the main HTTP server always runs
    */
   async setupDirectPromptingServer() {
-    const directPromptingEnabled =
-      process.env.DIRECT_PROMPTING_ENABLED !== "false";
-    logger.info(`🔍 Direct prompting enabled: ${directPromptingEnabled}`);
-    if (!directPromptingEnabled) return;
-
-    const protocol = process.env.DIRECT_PROMPTING_PROTOCOL || "websocket";
     const port = parseInt(process.env.DOCKER_PORT) || 3000;
-
-    logger.info(
-      `Setting up direct prompting server (${protocol}) on port ${port}`
-    );
-
-    if (protocol === "websocket") {
-      logger.info("📡 Setting up WebSocket server...");
-      await this.setupWebSocketServer(port);
-    } else if (protocol === "http") {
-      logger.info("🌐 Setting up HTTP prompting endpoints...");
+    const directPromptingEnabled = process.env.DIRECT_PROMPTING_ENABLED !== "false";
+    
+    logger.info(`🔍 Checking direct prompting setup:`);
+    logger.info(`   - DOCKER_PORT: ${process.env.DOCKER_PORT || 'not set (defaulting to 3000)'}`);
+    logger.info(`   - DIRECT_PROMPTING_ENABLED: ${process.env.DIRECT_PROMPTING_ENABLED || 'not set'}`);
+    logger.info(`   - Direct prompting enabled: ${directPromptingEnabled}`);
+    
+    // Always set up the /prompt endpoint if DIRECT_PROMPTING_ENABLED is not explicitly "false"
+    // The main HTTP server always runs, so the endpoint should be available
+    if (directPromptingEnabled) {
+      logger.info(`🌐 Setting up HTTP prompting endpoints on port ${port}...`);
       await this.setupHttpPromptingEndpoints();
+      logger.info("✅ Direct prompting endpoint (/prompt) configured");
     } else {
-      logger.warn(`⚠️  Unknown protocol: ${protocol}`);
+      logger.warn(`⚠️  Direct prompting is DISABLED - /prompt endpoint will not be available`);
+      logger.warn(`   Set DIRECT_PROMPTING_ENABLED=true or call setPromptingServer() to enable`);
     }
-
-    logger.info("✅ Direct prompting server setup completed");
-  }
-
-  /**
-   * Setup WebSocket server for direct prompting
-   */
-  async setupWebSocketServer(port) {
-    const WebSocket = require("ws");
-    const maxConnections =
-      parseInt(process.env.DIRECT_PROMPTING_MAX_CONNECTIONS) || 100;
-    const authentication =
-      process.env.DIRECT_PROMPTING_AUTHENTICATION === "true";
-
-    this.wsServer = new WebSocket.Server({
-      port: port,
-      host: "0.0.0.0",
-      maxClients: maxConnections,
-    });
-
-    this.activeConnections = 0;
-
-    logger.info(
-      `WebSocket server configured with max ${maxConnections} connections, auth: ${authentication}`
-    );
-
-    this.wsServer.on("connection", (ws, req) => {
-      const clientId = require("uuid").v4();
-      this.activeConnections++;
-      logger.info(
-        `WebSocket client connected: ${clientId} (${this.activeConnections}/${maxConnections})`
-      );
-
-      ws.on("message", async (message) => {
-        try {
-          const data = JSON.parse(message.toString());
-          const { prompt, conversationId, metadata } = data;
-
-          if (!prompt) {
-            ws.send(
-              JSON.stringify({
-                error: "Prompt is required",
-                timestamp: new Date().toISOString(),
-              })
-            );
-            return;
-          }
-
-          // Process the prompt with LLM
-          const response = await this.processDirectPrompt(prompt, {
-            conversationId,
-            metadata,
-            clientId,
-            protocol: "websocket",
-          });
-
-          // Send response back
-          ws.send(
-            JSON.stringify({
-              response: response.content,
-              conversationId: conversationId || response.conversationId,
-              metadata: response.metadata,
-              timestamp: new Date().toISOString(),
-            })
-          );
-        } catch (error) {
-          logger.error("WebSocket message processing error:", error);
-          ws.send(
-            JSON.stringify({
-              error: "Failed to process prompt",
-              message: error.message,
-              timestamp: new Date().toISOString(),
-            })
-          );
-        }
-      });
-
-      ws.on("close", () => {
-        this.activeConnections--;
-        logger.info(
-          `WebSocket client disconnected: ${clientId} (${this.activeConnections}/${maxConnections})`
-        );
-      });
-
-      ws.on("error", (error) => {
-        logger.error(`WebSocket error for client ${clientId}:`, error);
-      });
-    });
-
-    logger.info(`🔌 WebSocket server listening on port ${port}`);
-    logger.info(`🔗 Direct prompting endpoint: ws://localhost:${port}`);
   }
 
   /**
-   * Setup HTTP endpoints for direct prompting
+   * Setup HTTP endpoints for direct prompting (adds /prompt endpoint to main app)
    */
   async setupHttpPromptingEndpoints() {
-    logger.info("🔧 Setting up HTTP prompting endpoints...");
-    const port = parseInt(process.env.DOCKER_PORT) || 3000;
-    logger.info(`Port: ${port}, httpApp exists: ${!!this.httpApp}`);
-
-    if (!this.httpApp) {
-      // Create a minimal HTTP app for prompting if main HTTP is disabled
-      logger.info("Creating new Express app for HTTP prompting");
-      this.httpApp = express();
-      this.httpApp.use(express.json({ limit: "10mb" }));
-    }
+    logger.info("🔧 Setting up HTTP prompting endpoints on main server...");
 
-    // Direct prompting endpoint
-    this.httpApp.post("/prompt", async (req, res) => {
+    // Direct prompting endpoint on main app
+    this.mainApp.post("/prompt", async (req, res) => {
+      logger.info(`📥 Received POST /prompt request from ${req.ip || 'unknown'}`);
       try {
         const { prompt, conversationId, metadata } = req.body;
 
@@ -804,34 +723,9 @@ class AgentRuntime {
       }
     });
 
-    // Start the HTTP server if it's not already running
-    logger.info(
-      `HTTP server status: httpEnabled=${this.httpEnabled}, port=${port}`
-    );
-
-    if (!this.httpEnabled) {
-      // Only start if main HTTP server is not enabled
-      logger.info(`Starting HTTP direct prompting server on port ${port}...`);
-
-      try {
-        const server = this.httpApp.listen(port, "0.0.0.0", () => {
-          logger.info(
-            `🌐 HTTP direct prompting server listening on port ${port}`
-          );
-          logger.info(
-            `📡 Direct prompting endpoint: POST http://localhost:${port}/prompt`
-          );
-        });
-
-        server.on("error", (error) => {
-          logger.error(`HTTP server error:`, error);
-        });
-      } catch (error) {
-        logger.error(`Failed to start HTTP server:`, error);
-      }
-    } else {
-      logger.info(`📡 HTTP prompting endpoint added: POST /prompt`);
-    }
+    logger.info(`📡 HTTP prompting endpoint added: POST /prompt`);
+    logger.info(`   Full URL: http://localhost:${this.mainPort}/prompt`);
+    logger.info(`   Full URL: http://127.0.0.1:${this.mainPort}/prompt`);
   }
 
   /**
@@ -948,113 +842,6 @@ class AgentRuntime {
     }
   }
 
-  /**
-   * Wrap HTTP handler to emit tool events
-   */
-  wrapHttpHandlerWithEvents(method, path, originalHandler) {
-    return async (req, res) => {
-      const startTime = Date.now();
-      const requestId = require("uuid").v4();
-
-      try {
-        // Emit call event
-        this.emitEvent("tool:http-server:call", {
-          requestId,
-          method: method.toUpperCase(),
-          path,
-          headers: req.headers,
-          body: req.body,
-          query: req.query,
-          params: req.params,
-          timestamp: new Date().toISOString(),
-        });
-
-        // Emit specific method call event
-        this.emitEvent(`tool:http-server:call:${method.toLowerCase()}`, {
-          requestId,
-          path,
-          headers: req.headers,
-          body: req.body,
-          query: req.query,
-          params: req.params,
-          timestamp: new Date().toISOString(),
-        });
-
-        // Capture response data
-        const originalSend = res.send;
-        const originalJson = res.json;
-        let responseData = null;
-        let statusCode = 200;
-
-        res.send = function (data) {
-          responseData = data;
-          statusCode = res.statusCode;
-          return originalSend.call(this, data);
-        };
-
-        res.json = function (data) {
-          responseData = data;
-          statusCode = res.statusCode;
-          return originalJson.call(this, data);
-        };
-
-        // Execute original handler
-        const result = await originalHandler(req, res);
-
-        const processingTime = Date.now() - startTime;
-
-        // Emit response event
-        this.emitEvent("tool:http-server:response", {
-          requestId,
-          method: method.toUpperCase(),
-          path,
-          statusCode,
-          responseData,
-          processingTime,
-          timestamp: new Date().toISOString(),
-        });
-
-        // Emit specific method response event
-        this.emitEvent(`tool:http-server:response:${method.toLowerCase()}`, {
-          requestId,
-          path,
-          statusCode,
-          responseData,
-          processingTime,
-          timestamp: new Date().toISOString(),
-        });
-
-        // Emit wildcard events
-        this.emitEvent("tool:http-server:*", {
-          type: "response",
-          requestId,
-          method: method.toUpperCase(),
-          path,
-          statusCode,
-          responseData,
-          processingTime,
-          timestamp: new Date().toISOString(),
-        });
-
-        return result;
-      } catch (error) {
-        const processingTime = Date.now() - startTime;
-
-        // Emit error event
-        this.emitEvent("tool:http-server:error", {
-          requestId,
-          method: method.toUpperCase(),
-          path,
-          error: error.message,
-          stack: error.stack,
-          processingTime,
-          timestamp: new Date().toISOString(),
-        });
-
-        throw error;
-      }
-    };
-  }
 
   /**
    * Create tools proxy for agent runtime