testeranto 0.202.0 → 0.205.0

package/src/app/trash

@@ -0,0 +1,1697 @@
+
+// rootHtml(x: any) {
+//   throw new Error("Method not implemented.");
+// }
+
+// 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.");
+// }
+// }
+
+// private changeCallbacks: ((changes: FileChange[]) => void)[] = [];
+// private statusCallbacks: ((status: RemoteStatus) => void)[] = [];
+// private branchCallbacks: ((branch: string) => void)[] = [];
+// private fileCallbacks: Map<string, ((content: string) => void)[]> = new Map();
+// private directoryCallbacks: Map<string, ((entries: FileEntry[]) => void)[]> = new Map();
+
+// 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.");
+// }
+// fsTree(path: string): Promise<object> {
+//   throw new Error("Method not implemented.");
+// }
+// projectTree(project: string): Promise<object> {
+//   throw new Error("Method not implemented.");
+// }
+
+// private connectWebSocket() {
+//   // Ensure we're in a browser environment
+//   if (typeof window === "undefined") return;
+
+//   try {
+//     const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+//     const wsUrl = `${protocol}//${window.location.host}/api/git-ws`;
+//     this.ws = new WebSocket(wsUrl);
+
+//     this.ws.onopen = () => {
+//       console.log("Git WebSocket connected");
+//       // Request initial state
+//       if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+//         this.ws.send(JSON.stringify({ type: "get-initial-state" }));
+//       }
+//     };
+
+//     this.ws.onmessage = (event) => {
+//       try {
+//         const data = JSON.parse(event.data);
+//         switch (data.type) {
+//           case "changes":
+//             this.changeCallbacks.forEach((callback) =>
+//               callback(data.changes)
+//             );
+//             break;
+//           case "status":
+//             this.statusCallbacks.forEach((callback) => callback(data.status));
+//             break;
+//           case "branch":
+//             this.branchCallbacks.forEach((callback) => callback(data.branch));
+//             break;
+//           case "fileContent": {
+//             // Handle file content responses
+//             const fileCallbacks = this.fileCallbacks.get(data.path) || [];
+//             fileCallbacks.forEach((callback) => callback(data.content));
+//             this.fileCallbacks.delete(data.path);
+//             break;
+//           }
+//           case "directoryListing": {
+//             // Handle directory listing responses
+//             const dirCallbacks = this.directoryCallbacks.get(data.path) || [];
+//             dirCallbacks.forEach((callback) => callback(data.items));
+//             this.directoryCallbacks.delete(data.path);
+//             break;
+//           }
+//           case "error":
+//             console.error("Git WebSocket error:", data.message);
+//             // Reject pending callbacks
+//             if (data.path) {
+//               const fileCallbacks = this.fileCallbacks.get(data.path) || [];
+//               fileCallbacks.forEach((callback) => callback(""));
+//               this.fileCallbacks.delete(data.path);
+
+//               const dirCallbacks =
+//                 this.directoryCallbacks.get(data.path) || [];
+//               dirCallbacks.forEach((callback) => callback([]));
+//               this.directoryCallbacks.delete(data.path);
+//             }
+//             break;
+//         }
+//       } catch (error) {
+//         console.error("Error parsing WebSocket message:", error);
+//       }
+//     };
+
+//     this.ws.onclose = () => {
+//       console.log("Git WebSocket disconnected, attempting to reconnect...");
+//       setTimeout(() => this.connectWebSocket(), 3000);
+//     };
+
+//     this.ws.onerror = (error) => {
+//       console.error("Git WebSocket error:", error);
+//     };
+//   } catch (error) {
+//     console.error("Failed to connect Git WebSocket:", error);
+//   }
+// }
+
+// // Subscribe to real-time changes
+// onChanges(callback: (changes: FileChange[]) => void) {
+//   this.changeCallbacks.push(callback);
+//   return () => {
+//     this.changeCallbacks = this.changeCallbacks.filter(
+//       (cb) => cb !== callback
+//     );
+//   };
+// }
+
+// onStatusUpdate(callback: (status: RemoteStatus) => void) {
+//   this.statusCallbacks.push(callback);
+//   return () => {
+//     this.statusCallbacks = this.statusCallbacks.filter(
+//       (cb) => cb !== callback
+//     );
+//   };
+// }
+
+// onBranchUpdate(callback: (branch: string) => void) {
+//   this.branchCallbacks.push(callback);
+//   return () => {
+//     this.branchCallbacks = this.branchCallbacks.filter(
+//       (cb) => cb !== callback
+//     );
+//   };
+// }
+
+// private ensureWebSocketConnected(): Promise<void> {
+//   return new Promise((resolve, reject) => {
+//     // If already connected, resolve immediately
+//     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+//       resolve();
+//       return;
+//     }
+
+//     // If connecting in progress, wait for it
+//     if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+//       const onOpen = () => {
+//         this.ws?.removeEventListener("open", onOpen);
+//         resolve();
+//       };
+//       this.ws.addEventListener("open", onOpen);
+//       return;
+//     }
+
+//     // Connect if not connected
+//     this.connectWebSocket();
+
+//     // Wait for connection
+//     if (this.ws) {
+//       const onOpen = () => {
+//         this.ws?.removeEventListener("open", onOpen);
+//         resolve();
+//       };
+//       const onError = (error: Event) => {
+//         this.ws?.removeEventListener("error", onError);
+//         reject(new Error("Failed to connect WebSocket"));
+//       };
+//       this.ws.addEventListener("open", onOpen);
+//       this.ws.addEventListener("error", onError);
+//     } else {
+//       reject(new Error("Failed to create WebSocket"));
+//     }
+//   });
+// }
+
+// async readFile(path: string): Promise<string> {
+//   return new Promise(async (resolve, reject) => {
+//     try {
+//       await this.ensureWebSocketConnected();
+
+//       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//         reject(new Error("WebSocket is not connected"));
+//         return;
+//       }
+
+//       // Add callback
+//       if (!this.fileCallbacks.has(path)) {
+//         this.fileCallbacks.set(path, []);
+//       }
+//       const callbacks = this.fileCallbacks.get(path)!;
+//       callbacks.push(resolve);
+
+//       // Send request
+//       this.ws.send(
+//         JSON.stringify({
+//           type: "readFile",
+//           path,
+//         })
+//       );
+
+//       // Set timeout for error handling
+//       setTimeout(() => {
+//         const remainingCallbacks = this.fileCallbacks.get(path);
+//         if (remainingCallbacks && remainingCallbacks.length > 0) {
+//           remainingCallbacks.forEach((cb) => cb(""));
+//           this.fileCallbacks.delete(path);
+//           reject(new Error("Timeout reading file"));
+//         }
+//       }, 5000);
+//     } catch (error) {
+//       reject(error);
+//     }
+//   });
+// }
+
+// async readDirectory(path: string): Promise<FileEntry[]> {
+//   return new Promise(async (resolve, reject) => {
+//     try {
+//       await this.ensureWebSocketConnected();
+
+//       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//         reject(new Error("WebSocket is not connected"));
+//         return;
+//       }
+
+//       // Add callback
+//       if (!this.directoryCallbacks.has(path)) {
+//         this.directoryCallbacks.set(path, []);
+//       }
+//       const callbacks = this.directoryCallbacks.get(path)!;
+//       callbacks.push(resolve);
+
+//       // Send request
+//       this.ws.send(
+//         JSON.stringify({
+//           type: "listDirectory",
+//           path,
+//         })
+//       );
+
+//       // Set timeout for error handling
+//       setTimeout(() => {
+//         const remainingCallbacks = this.directoryCallbacks.get(path);
+//         if (remainingCallbacks && remainingCallbacks.length > 0) {
+//           remainingCallbacks.forEach((cb) => cb([]));
+//           this.directoryCallbacks.delete(path);
+//           reject(new Error("Timeout reading directory"));
+//         }
+//       }, 5000);
+//     } catch (error) {
+//       reject(error);
+//     }
+//   });
+// }
+
+// private async readDirectoryViaWebSocket(path: string): Promise<FileEntry[]> {
+//   // This should not be used - WebSocket communication should be handled separately
+//   throw new Error("WebSocket directory listing not implemented");
+// }
+
+// async exists(path: string): Promise<boolean> {
+//   try {
+//     await this.readFile(path);
+//     return true;
+//   } catch {
+//     return false;
+//   }
+// }
+
+// async writeFile(path: string, content: string): Promise<void> {
+//   await this.ensureWebSocketConnected();
+
+//   if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//     throw new Error("WebSocket is not connected");
+//   }
+
+//   this.ws.send(
+//     JSON.stringify({
+//       type: "writeFile",
+//       path,
+//       content,
+//     })
+//   );
+
+//   // For now, we'll assume it always succeeds
+//   // In a real implementation, we'd want to wait for a confirmation
+// }
+
+// async createDirectory(path: string): Promise<void> {
+//   await this.ensureWebSocketConnected();
+
+//   if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//     throw new Error("WebSocket is not connected");
+//   }
+
+//   this.ws.send(
+//     JSON.stringify({
+//       type: "createDirectory",
+//       path,
+//     })
+//   );
+
+//   // For now, we'll assume it always succeeds
+// }
+
+// async deleteFile(path: string): Promise<void> {
+//   await this.ensureWebSocketConnected();
+
+//   if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//     throw new Error("WebSocket is not connected");
+//   }
+
+//   this.ws.send(
+//     JSON.stringify({
+//       type: "deleteFile",
+//       path,
+//     })
+//   );
+
+//   // For now, we'll assume it always succeeds
+// }
+
+// async getFileStatus(path: string): Promise<FileStatus> {
+//   await this.ensureWebSocketConnected();
+//   const response = await fetch(
+//     `/api/git/status?path=${encodeURIComponent(path)}`
+//   );
+//   if (!response.ok) return { status: "unchanged" };
+//   return await response.json();
+// }
+
+// async getChanges(): Promise<FileChange[]> {
+//   try {
+//     await this.ensureWebSocketConnected();
+//     const response = await fetch("/api/git/changes");
+//     if (!response.ok) return [];
+//     const changes = await response.json();
+//     console.log("Raw changes from server:", JSON.stringify(changes, null, 2));
+//     return changes;
+//   } catch (error) {
+//     console.error("Error fetching changes:", error);
+//     return [];
+//   }
+// }
+
+// async commitChanges(message: string, description?: string): Promise<void> {
+//   await this.ensureWebSocketConnected();
+//   const response = await fetch("/api/git/commit", {
+//     method: "POST",
+//     headers: { "Content-Type": "application/json" },
+//     body: JSON.stringify({ message, description }),
+//   });
+//   if (!response.ok) {
+//     const error = await response.text();
+//     throw new Error(`Failed to commit changes: ${error}`);
+//   }
+
+//   // Request updated status after commit
+//   this.ws?.send(JSON.stringify({ type: "refresh-status" }));
+// }
+
+// async pushChanges(): Promise<void> {
+//   await this.ensureWebSocketConnected();
+//   const response = await fetch("/api/git/push", {
+//     method: "POST",
+//   });
+//   if (!response.ok) {
+//     const error = await response.text();
+//     throw new Error(`Failed to push changes: ${error}`);
+//   }
+
+//   this.ws?.send(JSON.stringify({ type: "refresh-status" }));
+// }
+
+// async pullChanges(): Promise<void> {
+//   await this.ensureWebSocketConnected();
+//   const response = await fetch("/api/git/pull", {
+//     method: "POST",
+//   });
+//   if (!response.ok) {
+//     const error = await response.text();
+//     throw new Error(`Failed to pull changes: ${error}`);
+//   }
+
+//   this.ws?.send(JSON.stringify({ type: "refresh-status" }));
+// }
+
+// async getCurrentBranch(): Promise<string> {
+//   await this.ensureWebSocketConnected();
+//   const response = await fetch("/api/git/branch");
+//   if (!response.ok) return "main";
+//   return await response.text();
+// }
+
+// async getRemoteStatus(): Promise<RemoteStatus> {
+//   await this.ensureWebSocketConnected();
+//   const response = await fetch("/api/git/remote-status");
+//   if (!response.ok) return { ahead: 0, behind: 0 };
+//   return await response.json();
+// }
+
+
+// /* eslint-disable @typescript-eslint/no-explicit-any */
+// /* eslint-disable no-async-promise-executor */
+// /* eslint-disable @typescript-eslint/no-unused-vars */
+
+// import fs from "@isomorphic-git/lightning-fs";
+// import git from "isomorphic-git";
+
+// import {
+//   FileService,
+//   FileChange,
+//   RemoteStatus,
+//   FileEntry,
+//   FileStatus,
+// } from "../FileService";
+// import { RawData, WebSocketServer } from "ws";
+// import http from "http";
+// import { spawn, ChildProcess } from "child_process";
+// import { WebSocketMessage } from "../../PM/types";
+// import { ApiEndpoint, ApiFilename } from "../api";
+
+// export class DevelopmentFileService extends FileService {
+//   // private ws: WebSocket;
+//   // private changeCallbacks: ((changes: FileChange[]) => void)[] = [];
+//   // private statusCallbacks: ((status: RemoteStatus) => void)[] = [];
+//   // private branchCallbacks: ((branch: string) => void)[] = [];
+//   // private fileCallbacks: Map<string, ((content: string) => void)[]> = new Map();
+//   // private directoryCallbacks: Map<string, ((entries: FileEntry[]) => void)[]> =
+//   //   new Map();
+
+//   wss: WebSocketServer;
+//   httpServer: http.Server;
+//   clients: Set<any> = new Set();
+
+//   public fs = new fs("testfs");
+
+//   // readonly connected: boolean = false;
+
+//   constructor() {
+//     super();
+
+//     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.method, req.url);
+
+//     // Parse the URL from the request
+//     const parsedUrl = new URL(req.url, `http://${req.headers.host}`);
+
+//     // Access the searchParams property, which is a URLSearchParams object
+//     const queryParams = parsedUrl.searchParams;
+
+//     if (req.url === "/testeranto/index.html") {
+//       this.rootHtml(res);
+//       return;
+//     } else if (req.url === ApiEndpoint.style) {
+//       this.appCss(res);
+//       return;
+//     } else {
+//       res.writeHead(404);
+//       res.end(`404 Not Found. ${req.url}`);
+//       return;
+//     }
+
+//     // Get a specific query parameter by name
+//     // const paramValue = queryParams.get("yourParamName");
+
+//     // if (req) {
+//     //   this.serveFileSync(indexPath, res, true);
+//     // }
+//   }
+
+//   appCss(res) {
+//     fs.readFile(ApiFilename.style, (err, data) => {
+//       if (err) {
+//         res.writeHead(404, { "Content-Type": "text/plain" });
+//         res.end(`500 ${err.toString()}`);
+//         return;
+//       }
+//       res.writeHead(200, { "Content-Type": "text/css" });
+//       res.end(data);
+//     });
+//   }
+
+//   rootHtml(res) {
+//     fs.readFile(ApiFilename.root, (err, data) => {
+//       if (err) {
+//         res.writeHead(404, { "Content-Type": "text/plain" });
+//         res.end(`500 ${err.toString()}`);
+//         return;
+//       }
+//       res.writeHead(200, { "Content-Type": "text/html" });
+//       res.end(data);
+//     });
+//   }
+
+//   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.");
+//   }
+
+//   rootHtml(x: any) {
+//     throw new Error("Method not implemented.");
+//   }
+
+//   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.");
+//   }
+
+//   // 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.");
+//   // }
+//   // fsTree(path: string): Promise<object> {
+//   //   throw new Error("Method not implemented.");
+//   // }
+//   // projectTree(project: string): Promise<object> {
+//   //   throw new Error("Method not implemented.");
+//   // }
+
+//   // private connectWebSocket() {
+//   //   // Ensure we're in a browser environment
+//   //   if (typeof window === "undefined") return;
+
+//   //   try {
+//   //     const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+//   //     const wsUrl = `${protocol}//${window.location.host}/api/git-ws`;
+//   //     this.ws = new WebSocket(wsUrl);
+
+//   //     this.ws.onopen = () => {
+//   //       console.log("Git WebSocket connected");
+//   //       // Request initial state
+//   //       if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+//   //         this.ws.send(JSON.stringify({ type: "get-initial-state" }));
+//   //       }
+//   //     };
+
+//   //     this.ws.onmessage = (event) => {
+//   //       try {
+//   //         const data = JSON.parse(event.data);
+//   //         switch (data.type) {
+//   //           case "changes":
+//   //             this.changeCallbacks.forEach((callback) =>
+//   //               callback(data.changes)
+//   //             );
+//   //             break;
+//   //           case "status":
+//   //             this.statusCallbacks.forEach((callback) => callback(data.status));
+//   //             break;
+//   //           case "branch":
+//   //             this.branchCallbacks.forEach((callback) => callback(data.branch));
+//   //             break;
+//   //           case "fileContent": {
+//   //             // Handle file content responses
+//   //             const fileCallbacks = this.fileCallbacks.get(data.path) || [];
+//   //             fileCallbacks.forEach((callback) => callback(data.content));
+//   //             this.fileCallbacks.delete(data.path);
+//   //             break;
+//   //           }
+//   //           case "directoryListing": {
+//   //             // Handle directory listing responses
+//   //             const dirCallbacks = this.directoryCallbacks.get(data.path) || [];
+//   //             dirCallbacks.forEach((callback) => callback(data.items));
+//   //             this.directoryCallbacks.delete(data.path);
+//   //             break;
+//   //           }
+//   //           case "error":
+//   //             console.error("Git WebSocket error:", data.message);
+//   //             // Reject pending callbacks
+//   //             if (data.path) {
+//   //               const fileCallbacks = this.fileCallbacks.get(data.path) || [];
+//   //               fileCallbacks.forEach((callback) => callback(""));
+//   //               this.fileCallbacks.delete(data.path);
+
+//   //               const dirCallbacks =
+//   //                 this.directoryCallbacks.get(data.path) || [];
+//   //               dirCallbacks.forEach((callback) => callback([]));
+//   //               this.directoryCallbacks.delete(data.path);
+//   //             }
+//   //             break;
+//   //         }
+//   //       } catch (error) {
+//   //         console.error("Error parsing WebSocket message:", error);
+//   //       }
+//   //     };
+
+//   //     this.ws.onclose = () => {
+//   //       console.log("Git WebSocket disconnected, attempting to reconnect...");
+//   //       setTimeout(() => this.connectWebSocket(), 3000);
+//   //     };
+
+//   //     this.ws.onerror = (error) => {
+//   //       console.error("Git WebSocket error:", error);
+//   //     };
+//   //   } catch (error) {
+//   //     console.error("Failed to connect Git WebSocket:", error);
+//   //   }
+//   // }
+
+//   // // Subscribe to real-time changes
+//   // onChanges(callback: (changes: FileChange[]) => void) {
+//   //   this.changeCallbacks.push(callback);
+//   //   return () => {
+//   //     this.changeCallbacks = this.changeCallbacks.filter(
+//   //       (cb) => cb !== callback
+//   //     );
+//   //   };
+//   // }
+
+//   // onStatusUpdate(callback: (status: RemoteStatus) => void) {
+//   //   this.statusCallbacks.push(callback);
+//   //   return () => {
+//   //     this.statusCallbacks = this.statusCallbacks.filter(
+//   //       (cb) => cb !== callback
+//   //     );
+//   //   };
+//   // }
+
+//   // onBranchUpdate(callback: (branch: string) => void) {
+//   //   this.branchCallbacks.push(callback);
+//   //   return () => {
+//   //     this.branchCallbacks = this.branchCallbacks.filter(
+//   //       (cb) => cb !== callback
+//   //     );
+//   //   };
+//   // }
+
+//   // private ensureWebSocketConnected(): Promise<void> {
+//   //   return new Promise((resolve, reject) => {
+//   //     // If already connected, resolve immediately
+//   //     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+//   //       resolve();
+//   //       return;
+//   //     }
+
+//   //     // If connecting in progress, wait for it
+//   //     if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+//   //       const onOpen = () => {
+//   //         this.ws?.removeEventListener("open", onOpen);
+//   //         resolve();
+//   //       };
+//   //       this.ws.addEventListener("open", onOpen);
+//   //       return;
+//   //     }
+
+//   //     // Connect if not connected
+//   //     this.connectWebSocket();
+
+//   //     // Wait for connection
+//   //     if (this.ws) {
+//   //       const onOpen = () => {
+//   //         this.ws?.removeEventListener("open", onOpen);
+//   //         resolve();
+//   //       };
+//   //       const onError = (error: Event) => {
+//   //         this.ws?.removeEventListener("error", onError);
+//   //         reject(new Error("Failed to connect WebSocket"));
+//   //       };
+//   //       this.ws.addEventListener("open", onOpen);
+//   //       this.ws.addEventListener("error", onError);
+//   //     } else {
+//   //       reject(new Error("Failed to create WebSocket"));
+//   //     }
+//   //   });
+//   // }
+
+//   // async readFile(path: string): Promise<string> {
+//   //   return new Promise(async (resolve, reject) => {
+//   //     try {
+//   //       await this.ensureWebSocketConnected();
+
+//   //       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//   //         reject(new Error("WebSocket is not connected"));
+//   //         return;
+//   //       }
+
+//   //       // Add callback
+//   //       if (!this.fileCallbacks.has(path)) {
+//   //         this.fileCallbacks.set(path, []);
+//   //       }
+//   //       const callbacks = this.fileCallbacks.get(path)!;
+//   //       callbacks.push(resolve);
+
+//   //       // Send request
+//   //       this.ws.send(
+//   //         JSON.stringify({
+//   //           type: "readFile",
+//   //           path,
+//   //         })
+//   //       );
+
+//   //       // Set timeout for error handling
+//   //       setTimeout(() => {
+//   //         const remainingCallbacks = this.fileCallbacks.get(path);
+//   //         if (remainingCallbacks && remainingCallbacks.length > 0) {
+//   //           remainingCallbacks.forEach((cb) => cb(""));
+//   //           this.fileCallbacks.delete(path);
+//   //           reject(new Error("Timeout reading file"));
+//   //         }
+//   //       }, 5000);
+//   //     } catch (error) {
+//   //       reject(error);
+//   //     }
+//   //   });
+//   // }
+
+//   // async readDirectory(path: string): Promise<FileEntry[]> {
+//   //   return new Promise(async (resolve, reject) => {
+//   //     try {
+//   //       await this.ensureWebSocketConnected();
+
+//   //       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//   //         reject(new Error("WebSocket is not connected"));
+//   //         return;
+//   //       }
+
+//   //       // Add callback
+//   //       if (!this.directoryCallbacks.has(path)) {
+//   //         this.directoryCallbacks.set(path, []);
+//   //       }
+//   //       const callbacks = this.directoryCallbacks.get(path)!;
+//   //       callbacks.push(resolve);
+
+//   //       // Send request
+//   //       this.ws.send(
+//   //         JSON.stringify({
+//   //           type: "listDirectory",
+//   //           path,
+//   //         })
+//   //       );
+
+//   //       // Set timeout for error handling
+//   //       setTimeout(() => {
+//   //         const remainingCallbacks = this.directoryCallbacks.get(path);
+//   //         if (remainingCallbacks && remainingCallbacks.length > 0) {
+//   //           remainingCallbacks.forEach((cb) => cb([]));
+//   //           this.directoryCallbacks.delete(path);
+//   //           reject(new Error("Timeout reading directory"));
+//   //         }
+//   //       }, 5000);
+//   //     } catch (error) {
+//   //       reject(error);
+//   //     }
+//   //   });
+//   // }
+
+//   // private async readDirectoryViaWebSocket(path: string): Promise<FileEntry[]> {
+//   //   // This should not be used - WebSocket communication should be handled separately
+//   //   throw new Error("WebSocket directory listing not implemented");
+//   // }
+
+//   // async exists(path: string): Promise<boolean> {
+//   //   try {
+//   //     await this.readFile(path);
+//   //     return true;
+//   //   } catch {
+//   //     return false;
+//   //   }
+//   // }
+
+//   // async writeFile(path: string, content: string): Promise<void> {
+//   //   await this.ensureWebSocketConnected();
+
+//   //   if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//   //     throw new Error("WebSocket is not connected");
+//   //   }
+
+//   //   this.ws.send(
+//   //     JSON.stringify({
+//   //       type: "writeFile",
+//   //       path,
+//   //       content,
+//   //     })
+//   //   );
+
+//   //   // For now, we'll assume it always succeeds
+//   //   // In a real implementation, we'd want to wait for a confirmation
+//   // }
+
+//   // async createDirectory(path: string): Promise<void> {
+//   //   await this.ensureWebSocketConnected();
+
+//   //   if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//   //     throw new Error("WebSocket is not connected");
+//   //   }
+
+//   //   this.ws.send(
+//   //     JSON.stringify({
+//   //       type: "createDirectory",
+//   //       path,
+//   //     })
+//   //   );
+
+//   //   // For now, we'll assume it always succeeds
+//   // }
+
+//   // async deleteFile(path: string): Promise<void> {
+//   //   await this.ensureWebSocketConnected();
+
+//   //   if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+//   //     throw new Error("WebSocket is not connected");
+//   //   }
+
+//   //   this.ws.send(
+//   //     JSON.stringify({
+//   //       type: "deleteFile",
+//   //       path,
+//   //     })
+//   //   );
+
+//   //   // For now, we'll assume it always succeeds
+//   // }
+
+//   // async getFileStatus(path: string): Promise<FileStatus> {
+//   //   await this.ensureWebSocketConnected();
+//   //   const response = await fetch(
+//   //     `/api/git/status?path=${encodeURIComponent(path)}`
+//   //   );
+//   //   if (!response.ok) return { status: "unchanged" };
+//   //   return await response.json();
+//   // }
+
+//   // async getChanges(): Promise<FileChange[]> {
+//   //   try {
+//   //     await this.ensureWebSocketConnected();
+//   //     const response = await fetch("/api/git/changes");
+//   //     if (!response.ok) return [];
+//   //     const changes = await response.json();
+//   //     console.log("Raw changes from server:", JSON.stringify(changes, null, 2));
+//   //     return changes;
+//   //   } catch (error) {
+//   //     console.error("Error fetching changes:", error);
+//   //     return [];
+//   //   }
+//   // }
+
+//   // async commitChanges(message: string, description?: string): Promise<void> {
+//   //   await this.ensureWebSocketConnected();
+//   //   const response = await fetch("/api/git/commit", {
+//   //     method: "POST",
+//   //     headers: { "Content-Type": "application/json" },
+//   //     body: JSON.stringify({ message, description }),
+//   //   });
+//   //   if (!response.ok) {
+//   //     const error = await response.text();
+//   //     throw new Error(`Failed to commit changes: ${error}`);
+//   //   }
+
+//   //   // Request updated status after commit
+//   //   this.ws?.send(JSON.stringify({ type: "refresh-status" }));
+//   // }
+
+//   // async pushChanges(): Promise<void> {
+//   //   await this.ensureWebSocketConnected();
+//   //   const response = await fetch("/api/git/push", {
+//   //     method: "POST",
+//   //   });
+//   //   if (!response.ok) {
+//   //     const error = await response.text();
+//   //     throw new Error(`Failed to push changes: ${error}`);
+//   //   }
+
+//   //   this.ws?.send(JSON.stringify({ type: "refresh-status" }));
+//   // }
+
+//   // async pullChanges(): Promise<void> {
+//   //   await this.ensureWebSocketConnected();
+//   //   const response = await fetch("/api/git/pull", {
+//   //     method: "POST",
+//   //   });
+//   //   if (!response.ok) {
+//   //     const error = await response.text();
+//   //     throw new Error(`Failed to pull changes: ${error}`);
+//   //   }
+
+//   //   this.ws?.send(JSON.stringify({ type: "refresh-status" }));
+//   // }
+
+//   // async getCurrentBranch(): Promise<string> {
+//   //   await this.ensureWebSocketConnected();
+//   //   const response = await fetch("/api/git/branch");
+//   //   if (!response.ok) return "main";
+//   //   return await response.text();
+//   // }
+
+//   // async getRemoteStatus(): Promise<RemoteStatus> {
+//   //   await this.ensureWebSocketConnected();
+//   //   const response = await fetch("/api/git/remote-status");
+//   //   if (!response.ok) return { ahead: 0, behind: 0 };
+//   //   return await response.json();
+//   // }
+// }
+
+// // r 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;
+// //     }
+// //   }
+
+
+  // useEffect(() => {
+  //   if (!projectName || !testPath || !runtime) return;
+  //   setTestName(testPath);
+
+  //   const fetchData = async () => {
+  //     try {
+  //       const [testResponse, metafileRes] = await Promise.all([
+  //         fetchTestData(projectName, testPath, runtime),
+  //         fetch(`metafiles/${runtime}/${projectName}.json`),
+  //       ]);
+
+  //       fetchDataUtil(
+  //         testResponse,
+  //         metafileRes,
+  //         testPath,
+  //         setLogs,
+  //         projectName,
+  //         setSummary,
+  //         setErrorCounts,
+  //         setTestsExist,
+  //         runtime
+  //       );
+  //     } catch (err) {
+  //       setError(err instanceof Error ? err.message : "Unknown error");
+  //       setTestsExist(false);
+  //     } finally {
+  //       setLoading(false);
+  //     }
+  //   };
+
+  //   fetchData();
+  // }, []);