testeranto 0.202.0 → 0.205.0

package/src/app/backend/PM_WithTCP.ts

@@ -0,0 +1,777 @@
+// DEPRECATED
+//
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { ChildProcess, spawn } from "child_process";
+import http from "http";
+import { RawData, WebSocketServer } from "ws";
+import fs from "fs";
+
+import { IBuiltConfig } from "../../Types.js";
+import { WebSocketMessage } from "../../PM/types.js";
+
+import { FileService } from "../FileService.js";
+
+import { PM_Base } from "./PM_0.js";
+
+export abstract class PM_WithTCP extends PM_Base implements FileService {
+  wss: WebSocketServer;
+  httpServer: http.Server;
+  clients: Set<any> = new Set();
+
+  runningProcesses: Map<string, ChildProcess | Promise<any>> = new Map();
+
+  allProcesses: Map<
+    string,
+    {
+      child?: ChildProcess;
+      promise?: Promise<any>;
+      status: "running" | "exited" | "error" | "completed";
+      exitCode?: number;
+      error?: string;
+      command: string;
+      pid?: number;
+      timestamp: string;
+      type: "process" | "promise";
+      category: "aider" | "bdd-test" | "build-time" | "other";
+      testName?: string;
+      platform?: "node" | "web" | "pure" | "python" | "golang";
+    }
+  > = new Map();
+  processLogs: Map<string, string[]> = new Map();
+
+  constructor(configs: IBuiltConfig, name, mode) {
+    super(configs, name, mode);
+
+    this.httpServer = http.createServer(this.handleHttpRequest.bind(this));
+
+    this.wss = new WebSocketServer({ server: this.httpServer });
+
+    this.wss.on("connection", (ws) => {
+      this.clients.add(ws);
+      console.log("Client connected");
+
+      ws.on("message", (data) => {
+        try {
+          this.websocket(data, ws);
+        } catch (error) {
+          console.error("Error handling WebSocket message:", error);
+        }
+      });
+
+      ws.on("close", () => {
+        this.clients.delete(ws);
+        console.log("Client disconnected");
+      });
+
+      ws.on("error", (error) => {
+        console.error("WebSocket error:", error);
+        this.clients.delete(ws);
+      });
+    });
+
+    const httpPort = Number(process.env.HTTP_PORT) || 3000;
+
+    this.httpServer.on("error", (error) => {
+      console.error("HTTP server error:", error);
+      if ((error as any).code === "EADDRINUSE") {
+        console.error(
+          `Port ${httpPort} is already in use. Please use a different port.`
+        );
+      }
+      process.exit(-1);
+    });
+
+    this.httpServer.listen(httpPort, "0.0.0.0", () => {
+      console.log(`HTTP server running on http://localhost:${httpPort}`);
+    });
+  }
+
+  websocket(data: RawData, ws: any) {
+    try {
+      const message: WebSocketMessage = JSON.parse(data.toString());
+
+      if (message.type === "chatMessage") {
+        // Always record the message, even if aider is not available
+        console.log(`Received chat message: ${message.content}`);
+
+        // Pass to PM_WithHelpo if available
+        if ((this as any).handleChatMessage) {
+          (this as any).handleChatMessage(message.content);
+        } else {
+          console.log("PM_WithHelpo not available - message not processed");
+        }
+        return;
+      }
+
+      // Handle file operations via WebSocket
+      if (message.type === "listDirectory") {
+        // this.handleListDirectory(ws, message);
+      } else if (message.type === "readFile") {
+        // this.handleReadFile(ws, message);
+      } else if (message.type === "writeFile") {
+        // this.handleWriteFile(ws, message);
+      } else if (message.type === "createDirectory") {
+        // this.handleCreateDirectory(ws, message);
+      } else if (message.type === "deleteFile") {
+        // this.handleDeleteFile(ws, message);
+      } else if (message.type === "executeCommand") {
+        // const executeMessage = message as ExecuteCommandMessage;
+
+        if (message.command && message.command.trim().startsWith("aider")) {
+          console.log(`Executing command: ${message.command}`);
+
+          const processId = Date.now().toString();
+          const child = spawn(message.command, {
+            shell: true,
+            cwd: process.cwd(),
+          });
+
+          this.runningProcesses.set(processId, child);
+          this.allProcesses.set(processId, {
+            child,
+            status: "running",
+            command: message.command,
+            pid: child.pid,
+            timestamp: new Date().toISOString(),
+            type: "process",
+            category: "aider",
+          });
+
+          this.processLogs.set(processId, []);
+
+          this.webSocketBroadcastMessage({
+            type: "processStarted",
+            processId,
+            command: message.command,
+            timestamp: new Date().toISOString(),
+            logs: [],
+          });
+
+          // Capture stdout and stderr
+          child.stdout?.on("data", (data) => {
+            const logData = data.toString();
+            const logs = this.processLogs.get(processId) || [];
+            logs.push(logData);
+            this.processLogs.set(processId, logs);
+
+            this.webSocketBroadcastMessage({
+              type: "processStdout",
+              processId,
+              data: logData,
+              timestamp: new Date().toISOString(),
+            });
+          });
+
+          child.stderr?.on("data", (data) => {
+            const logData = data.toString();
+            const logs = this.processLogs.get(processId) || [];
+            logs.push(logData);
+            this.processLogs.set(processId, logs);
+
+            this.webSocketBroadcastMessage({
+              type: "processStderr",
+              processId,
+              data: logData,
+              timestamp: new Date().toISOString(),
+            });
+          });
+
+          child.on("error", (error) => {
+            console.error(`Failed to execute command: ${error}`);
+            this.runningProcesses.delete(processId);
+            const processInfo = this.allProcesses.get(processId);
+            if (processInfo) {
+              this.allProcesses.set(processId, {
+                ...processInfo,
+                status: "error",
+                error: error.message,
+              });
+            }
+            this.webSocketBroadcastMessage({
+              type: "processError",
+              processId,
+              error: error.message,
+              timestamp: new Date().toISOString(),
+            });
+          });
+
+          child.on("exit", (code) => {
+            console.log(`Command exited with code ${code}`);
+            this.runningProcesses.delete(processId);
+            const processInfo = this.allProcesses.get(processId);
+            if (processInfo) {
+              this.allProcesses.set(processId, {
+                ...processInfo,
+                status: "exited",
+                // @ts-ignore
+                exitCode: code,
+              });
+            }
+            this.webSocketBroadcastMessage({
+              type: "processExited",
+              processId,
+              exitCode: code,
+              timestamp: new Date().toISOString(),
+            });
+          });
+        } else {
+          console.error('Invalid command: must start with "aider"');
+        }
+      } else if (message.type === "getRunningProcesses") {
+        const processes = Array.from(this.allProcesses.entries()).map(
+          ([id, procInfo]) => ({
+            processId: id,
+            command: procInfo.command,
+            pid: procInfo.pid,
+            status: procInfo.status,
+            exitCode: procInfo.exitCode,
+            error: procInfo.error,
+            timestamp: procInfo.timestamp,
+            category: procInfo.category,
+            testName: procInfo.testName,
+            platform: procInfo.platform,
+            logs: this.processLogs.get(id) || [],
+          })
+        );
+        ws.send(
+          JSON.stringify({
+            type: "runningProcesses",
+            processes,
+          })
+        );
+      } else if (message.type === "getProcess") {
+        const processId = message.processId;
+        const procInfo = this.allProcesses.get(processId);
+        if (procInfo) {
+          ws.send(
+            JSON.stringify({
+              type: "processData",
+              processId,
+              command: procInfo.command,
+              pid: procInfo.pid,
+              status: procInfo.status,
+              exitCode: procInfo.exitCode,
+              error: procInfo.error,
+              timestamp: procInfo.timestamp,
+              category: procInfo.category,
+              testName: procInfo.testName,
+              platform: procInfo.platform,
+              logs: this.processLogs.get(processId) || [],
+            })
+          );
+        }
+      } else if (message.type === "stdin") {
+        const processId = message.processId;
+        const data = message.data;
+        console.log("Received stdin for process", processId, ":", data);
+        const childProcess = this.runningProcesses.get(
+          processId
+        ) as ChildProcess;
+
+        if (childProcess && childProcess.stdin) {
+          console.log("Writing to process stdin");
+          childProcess.stdin.write(data);
+        } else {
+          console.log(
+            "Cannot write to stdin - process not found or no stdin:",
+            {
+              processExists: !!childProcess,
+              stdinExists: childProcess?.stdin ? true : false,
+            }
+          );
+        }
+      } else if (message.type === "killProcess") {
+        const processId = message.processId;
+        console.log("Received killProcess for process", processId);
+        const childProcess = this.runningProcesses.get(
+          processId
+        ) as ChildProcess;
+
+        if (childProcess) {
+          console.log("Killing process");
+          childProcess.kill("SIGTERM");
+          // The process exit handler will update the status and broadcast the change
+        } else {
+          console.log("Cannot kill process - process not found:", {
+            processExists: !!childProcess,
+          });
+        }
+      } else if (message.type === "getChatHistory") {
+        if ((this as any).getChatHistory) {
+          (this as any)
+            .getChatHistory()
+            .then((history: any) => {
+              ws.send(
+                JSON.stringify({
+                  type: "chatHistory",
+                  messages: history,
+                })
+              );
+            })
+            .catch((error: any) => {
+              console.error("Error getting chat history:", error);
+              ws.send(
+                JSON.stringify({
+                  type: "error",
+                  message: "Failed to get chat history",
+                })
+              );
+            });
+        }
+      }
+    } catch (error) {
+      console.error("Error handling WebSocket message:", error);
+    }
+  }
+
+  webSocketBroadcastMessage(message: any) {
+    const data =
+      typeof message === "string" ? message : JSON.stringify(message);
+    this.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        client.send(data);
+      }
+    });
+  }
+
+  handleHttpRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse<http.IncomingMessage> & {
+      req: http.IncomingMessage;
+    }
+  ) {
+    console.log(req, res);
+
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+    });
+
+    res.end(JSON.stringify({ wtf: "idk" }));
+  }
+
+  writeFile(path: string, content: string): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  readFile(path: string): Promise<string> {
+    throw new Error("Method not implemented.");
+  }
+  createDirectory(path: string): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  deleteFile(path: string): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  files(path: string): Promise<object> {
+    throw new Error("Method not implemented.");
+  }
+  projects(project: string): Promise<string[]> {
+    throw new Error("Method not implemented.");
+  }
+  tests(project: string): Promise<string[]> {
+    throw new Error("Method not implemented.");
+  }
+  report(project: string, test: string): Promise<object> {
+    throw new Error("Method not implemented.");
+  }
+
+  // Add connection listener to see if connections are being made
+  // this.httpServer.on("connection", (socket) => {
+  //   // console.log(
+  //   //   "New TCP connection from:",
+  //   //   socket.remoteAddress,
+  //   //   socket.remotePort
+  //   // );
+
+  //   // Track when the connection is closed
+  //   // socket.on("close", () => {
+  //   //   console.log(
+  //   //     "TCP connection closed:",
+  //   //     socket.remoteAddress,
+  //   //     socket.remotePort
+  //   //   );
+  //   // });
+
+  //   // Track errors on the socket
+  //   // socket.on("error", (error) => {
+  //   //   console.log(
+  //   //     "TCP connection error from:",
+  //   //     socket.remoteAddress,
+  //   //     socket.remotePort,
+  //   //     error
+  //   //   );
+  //   // });
+  // });
+
+  // Add request listener to see HTTP requests
+  // this.httpServer.on("request", (req, res) => {
+  //   // console.log(
+  //   //   "HTTP request received:",
+  //   //   req.method,
+  //   //   req.url,
+  //   //   "from",
+  //   //   req.socket.remoteAddress,
+  //   //   req.socket.remotePort
+  //   // );
+
+  //   // // Track when the response is finished
+  //   // res.on("finish", () => {
+  //   //   console.log("HTTP response sent:", res.statusCode, req.method, req.url);
+  //   // });
+  // });
+
+  // httpRequest(req: http.IncomingMessage, res: http.ServerResponse) {
+  //   console.log(`httpRequest method called for ${req.method} ${req.url}`);
+
+  //   res.writeHead(200, {
+  //     "Content-Type": "application/json",
+  //   });
+
+  //   // Convert object to JSON string and send
+  //   res.end(JSON.stringify({ wtf: "idk" }));
+
+  //   // // Ensure response is always completed
+  //   // // const completeResponse = () => {
+  //   // //   if (!res.writableEnded && !res.headersSent) {
+  //   // //     res.writeHead(200, { "Content-Type": "text/plain" });
+  //   // //     res.end("Default response");
+  //   // //     console.log("Complete response sent");
+  //   // //   } else {
+  //   // //     console.log("Response already completed, not sending default");
+  //   // //   }
+  //   // // };
+
+  //   // // Handle CORS headers for all responses
+  //   // res.setHeader("Access-Control-Allow-Origin", "*");
+  //   // res.setHeader(
+  //   //   "Access-Control-Allow-Methods",
+  //   //   "GET, POST, OPTIONS, PUT, DELETE"
+  //   // );
+  //   // res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  //   // // Handle preflight requests
+  //   // if (req.method === "OPTIONS") {
+  //   //   res.writeHead(200);
+  //   //   res.end();
+  //   //   return;
+  //   // }
+
+  //   // // Ensure response is always sent
+  //   // const sendResponse = (
+  //   //   status: number,
+  //   //   contentType: string,
+  //   //   body: string | Buffer
+  //   // ) => {
+  //   //   res.writeHead(200, {
+  //   //     "Content-Type": "application/json",
+  //   //   });
+
+  //   //   // Convert object to JSON string and send
+  //   //   res.end(JSON.stringify({ wtf: "idk" }));
+
+  //   //   // res.json("Hello from Express!");
+  //   //   // console.log('sendResponse called with:', { status, contentType, body: body.toString().substring(0, 50) });
+  //   //   // if (!res.headersSent) {
+  //   //   //   try {
+  //   //   //     console.log('About to write headers and end response');
+  //   //   //     res.writeHead(status, { "Content-Type": contentType });
+  //   //   //     res.end(body);
+  //   //   //     console.log('Response sent via sendResponse');
+  //   //   //   } catch (error) {
+  //   //   //     console.error('Error sending response:', error);
+  //   //   //   }
+  //   //   // } else {
+  //   //   //   console.warn('Headers already sent, cannot send response');
+  //   //   // }
+  //   // };
+
+  //   // try {
+
+  //   //   console.log(`Processing ${req.method} request for: ${req.url}`);
+  //   //   console.log("Response writable state:", {
+  //   //     writable: res.writable,
+  //   //     destroyed: res.destroyed,
+  //   //     writableEnded: res.writableEnded,
+  //   //     writableFinished: res.writableFinished,
+  //   //     headersSent: res.headersSent,
+  //   //   });
+
+  //   //   // Handle root path
+  //   //   if (req.url === "/") {
+  //   //     sendResponse(
+  //   //       200,
+  //   //       "text/plain",
+  //   //       "HTTP Server is working! Try /test endpoint"
+  //   //     );
+  //   //     return;
+  //   //   }
+
+  //   //   // Handle test endpoint
+  //   //   if (req.url === "/test") {
+  //   //     sendResponse(200, "text/plain", "Test endpoint is working!");
+  //   //     return;
+  //   //   }
+
+  //   //   // Handle specific requests
+  //   //   if (req.url === "/testeranto/projects.html") {
+  //   //     console.log("Handling projects.html request - before sendResponse");
+  //   //     sendResponse(
+  //   //       200,
+  //   //       "text/html",
+  //   //       "<html><body><h1>Projects</h1></body></html>"
+  //   //     );
+  //   //     console.log("Handling projects.html request - after sendResponse");
+  //   //     return;
+  //   //   }
+
+  //   //   // Send a simple response for all other requests
+  //   //   console.log("Handling other request");
+  //   //   sendResponse(
+  //   //     200,
+  //   //     "text/plain",
+  //   //     `Server is working! Request received for: ${req.url}`
+  //   //   );
+  //   //   return;
+
+  //   //   // The rest of the original code is commented out for now
+  //   //   /*
+  //   //   const parsedUrl = url.parse(req.url || "/", true);
+  //   //   const pathname = parsedUrl.pathname || "/";
+
+  //   //   // Handle API requests
+  //   //   if (pathname?.startsWith("/api/")) {
+  //   //     console.log("API request received:", pathname);
+  //   //     // If there's an API handler, use it
+  //   //     if ((this as any).apiRequest) {
+  //   //       (this as any).apiRequest(req, res);
+  //   //     } else {
+  //   //       sendResponse(404, "application/json", JSON.stringify({ error: "API endpoint not found" }));
+  //   //     }
+  //   //     return;
+  //   //   }
+
+  //   //   // Handle root path with a simple response for testing
+  //   //   if (pathname === "/") {
+  //   //     sendResponse(200, "text/plain", "HTTP Server is working!");
+  //   //     return;
+  //   //   }
+
+  //   //   // Handle static file serving
+  //   //   console.log("Handling static file serving for path:", pathname);
+  //   //   const processedPathname = pathname;
+
+  //   //   // Remove leading slash to get file path
+  //   //   let filePath = processedPathname.substring(1);
+  //   //   console.log("Looking for file:", filePath);
+
+  //   //   // Handle special cases
+  //   //   if (filePath.startsWith("reports/")) {
+  //   //     filePath = `testeranto/${filePath}`;
+  //   //   } else if (filePath.startsWith("metafiles/")) {
+  //   //     filePath = `testeranto/${filePath}`;
+  //   //   } else if (filePath === "projects.json") {
+  //   //     // Keep as is
+  //   //   } else {
+  //   //     // For frontend assets, try to find the file
+  //   //     const possiblePaths = [
+  //   //       `dist/${filePath}`,
+  //   //       `testeranto/dist/${filePath}`,
+  //   //       `../dist/${filePath}`,
+  //   //       `./${filePath}`,
+  //   //     ];
+  //   //     console.log("Checking possible paths:", possiblePaths);
+
+  //   //     // Find the first existing file
+  //   //     let foundPath = null;
+  //   //     for (const possiblePath of possiblePaths) {
+  //   //       try {
+  //   //         if (fs.existsSync(possiblePath)) {
+  //   //           foundPath = possiblePath;
+  //   //           console.log("Found file at:", foundPath);
+  //   //           break;
+  //   //         }
+  //   //       } catch (error) {
+  //   //         // Continue to next path
+  //   //       }
+  //   //     }
+
+  //   //     if (foundPath) {
+  //   //       filePath = foundPath;
+  //   //     } else {
+  //   //       console.log("File not found, serving index.html or fallback");
+  //   //       // Serve index.html for SPA routing
+  //   //       const indexPath = this.findIndexHtml();
+  //   //       if (indexPath) {
+  //   //         this.serveFileSync(indexPath, res, true);
+  //   //       } else {
+  //   //         sendResponse(200, "text/html", `
+  //   //           <html>
+  //   //             <body>
+  //   //               <h1>Testeranto is running</h1>
+  //   //               <p>Frontend files are not built yet. Run 'npm run build' to build the frontend.</p>
+  //   //             </body>
+  //   //           </html>
+  //   //         `);
+  //   //       }
+  //   //       return;
+  //   //     }
+  //   //   }
+
+  //   //   // Check if file exists and serve it using synchronous check
+  //   //   try {
+  //   //     console.log("Final file path to serve:", filePath);
+  //   //     if (!fs.existsSync(filePath)) {
+  //   //       console.log("File does not exist:", filePath);
+  //   //       // For SPA routing, serve index.html
+  //   //       const indexPath = this.findIndexHtml();
+  //   //       if (indexPath) {
+  //   //         this.serveFileSync(indexPath, res, true);
+  //   //       } else {
+  //   //         sendResponse(404, "text/plain", "404 Not Found");
+  //   //       }
+  //   //       return;
+  //   //     }
+
+  //   //     console.log("Serving file:", filePath);
+  //   //     this.serveFileSync(filePath, res, false);
+  //   //   } catch (error) {
+  //   //     console.error(`Error checking file existence for ${filePath}:`, error);
+  //   //     sendResponse(500, "text/plain", "500 Internal Server Error");
+  //   //   }
+  //   //   */
+  //   // } catch (error) {
+  //   //   console.error("Unexpected error handling request:", error);
+  //   //   try {
+  //   //     if (!res.headersSent) {
+  //   //       sendResponse(500, "text/plain", "Internal Server Error");
+  //   //     } else {
+  //   //       console.log("Headers already sent, cannot send error response");
+  //   //     }
+  //   //   } catch (sendError) {
+  //   //     console.error("Failed to send error response:", sendError);
+  //   //     // Try to end the response directly
+  //   //     if (!res.writableEnded) {
+  //   //       res.destroy();
+  //   //     }
+  //   //   }
+  //   // } finally {
+  //   //   // Only complete the response if nothing was sent
+  //   //   console.log("Finally block - response state:", {
+  //   //     headersSent: res.headersSent,
+  //   //     writableEnded: res.writableEnded,
+  //   //     writableFinished: res.writableFinished,
+  //   //   });
+  //   //   if (!res.headersSent && !res.writableEnded) {
+  //   //     console.log("No response sent, calling completeResponse");
+  //   //     completeResponse();
+  //   //   } else {
+  //   //     console.log("Response already handled, skipping completeResponse");
+  //   //   }
+  //   // }
+  // }
+
+  // findIndexHtml(): string | null {
+  //   const possiblePaths = [
+  //     "dist/index.html",
+  //     "testeranto/dist/index.html",
+  //     "../dist/index.html",
+  //     "./index.html",
+  //   ];
+
+  //   for (const path of possiblePaths) {
+  //     try {
+  //       if (fs.existsSync(path)) {
+  //         return path;
+  //       }
+  //     } catch (error) {
+  //       // Continue to next path
+  //     }
+  //   }
+  //   return null;
+  // }
+}
+
+// private serveFile(
+//     filePath: string,
+//     res: http.ServerResponse,
+//     isSpaFallback: boolean
+//   ) {
+//     // Use the synchronous version
+//     this.serveFileSync(filePath, res, isSpaFallback);
+//   }
+
+// private serveFileSync(
+//     filePath: string,
+//     res: http.ServerResponse,
+//     isSpaFallback: boolean
+//   ) {
+//     // Ensure response is always sent
+//     const sendResponse = (
+//       status: number,
+//       contentType: string,
+//       body: string | Buffer
+//     ) => {
+//       if (!res.headersSent) {
+//         res.writeHead(status, { "Content-Type": contentType });
+//         res.end(body);
+//       }
+//     };
+
+//     // Check if the file exists using synchronous check
+//     try {
+//       if (!fs.existsSync(filePath) && !isSpaFallback) {
+//         // Try to serve index.html as fallback for SPA routing
+//         const indexPath = this.findIndexHtml();
+//         if (indexPath) {
+//           this.serveFileSync(indexPath, res, true);
+//           return;
+//         } else {
+//           sendResponse(404, "text/plain", "404 Not Found");
+//           return;
+//         }
+//       } else if (!fs.existsSync(filePath) && isSpaFallback) {
+//         sendResponse(404, "text/plain", "404 Not Found");
+//         return;
+//       }
+
+//       // File exists, read and serve it
+//       try {
+//         const data = fs.readFileSync(filePath);
+
+//         // For HTML files, inject the configuration
+//         if (filePath.endsWith(".html")) {
+//           let content = data.toString();
+//           // Inject the configuration script before the closing </body> tag
+//           if (content.includes("</body>")) {
+//             const configScript = `
+//                   <script>
+//                     window.testerantoConfig = ${JSON.stringify({
+//                       githubOAuth: {
+//                         clientId: process.env.GITHUB_CLIENT_ID || "",
+//                       },
+//                       serverOrigin:
+//                         process.env.SERVER_ORIGIN || "http://localhost:3000",
+//                     })};
+//                   </script>
+//                 `;
+//             content = content.replace("</body>", `${configScript}</body>`);
+//           }
+//           sendResponse(200, "text/html", content);
+//         } else {
+//           // Get MIME type for other files
+//           const mimeType = mime.lookup(filePath) || "application/octet-stream";
+//           sendResponse(200, mimeType, data);
+//         }
+//       } catch (error) {
+//         console.error(`Error reading file ${filePath}:`, error);
+//         sendResponse(500, "text/plain", "500 Internal Server Error");
+//         return;
+//       }
+//     } catch (error) {
+//       console.error(`Error checking file existence for ${filePath}:`, error);
+//       sendResponse(500, "text/plain", "500 Internal Server Error");
+//       return;
+//     }
+//   }