testeranto 0.177.0 → 0.197.0

package/src/PM/main.ts

@@ -2,6 +2,7 @@
 /* eslint-disable no-async-promise-executor */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
+
 import { ChildProcess, spawn } from "node:child_process";
 import ansiColors from "ansi-colors";
 import net from "net";
@@ -11,6 +12,10 @@ import path from "path";
 import puppeteer, { ConsoleMessage } from "puppeteer-core";
 import ansiC from "ansi-colors";
 import crypto from "node:crypto";
+import { WebSocketServer } from "ws";
+import http from "http";
+import url from "url";
+import mime from "mime-types";
 
 import {
   IFinalResults,
@@ -37,6 +42,113 @@ const fileHashes = {};
 const files: Record<string, Set<string>> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
+type LogStreams = {
+  closeAll: () => void;
+  writeExitCode: (code: number, error?: Error) => void;
+  stdout?: fs.WriteStream;
+  stderr?: fs.WriteStream;
+  info?: fs.WriteStream;
+  warn?: fs.WriteStream;
+  error?: fs.WriteStream;
+  debug?: fs.WriteStream;
+  exit: fs.WriteStream;
+};
+
+function runtimeLogs(
+  runtime: IRunTime,
+  reportDest: string
+): Record<string, fs.WriteStream> {
+  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+
+  try {
+    if (!fs.existsSync(safeDest)) {
+      fs.mkdirSync(safeDest, { recursive: true });
+    }
+
+    if (runtime === "node") {
+      return {
+        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else if (runtime === "web") {
+      return {
+        info: fs.createWriteStream(`${safeDest}/info.log`),
+        warn: fs.createWriteStream(`${safeDest}/warn.log`),
+        error: fs.createWriteStream(`${safeDest}/error.log`),
+        debug: fs.createWriteStream(`${safeDest}/debug.log`),
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else if (runtime === "pure") {
+      return {
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else {
+      throw `unknown runtime: ${runtime}`;
+    }
+  } catch (e) {
+    console.error(`Failed to create log streams in ${safeDest}:`, e);
+    throw e;
+  }
+}
+
+function createLogStreams(reportDest: string, runtime: IRunTime): LogStreams {
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(reportDest)) {
+    fs.mkdirSync(reportDest, { recursive: true });
+  }
+
+  const streams = runtimeLogs(runtime, reportDest);
+
+  // const streams = {
+  //   exit: fs.createWriteStream(`${reportDest}/exit.log`),
+  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+
+  try {
+    if (!fs.existsSync(safeDest)) {
+      fs.mkdirSync(safeDest, { recursive: true });
+    }
+
+    const streams = runtimeLogs(runtime, safeDest);
+    // const streams = {
+    //   exit: fs.createWriteStream(`${safeDest}/exit.log`),
+    //   ...(runtime === "node" || runtime === "pure"
+    //     ? {
+    //         stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+    //         stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+    //       }
+    //     : {
+    //         info: fs.createWriteStream(`${safeDest}/info.log`),
+    //         warn: fs.createWriteStream(`${safeDest}/warn.log`),
+    //         error: fs.createWriteStream(`${safeDest}/error.log`),
+    //         debug: fs.createWriteStream(`${safeDest}/debug.log`),
+    //       }),
+    // };
+
+    return {
+      ...streams,
+      closeAll: () => {
+        Object.values(streams).forEach(
+          (stream) => !stream.closed && stream.close()
+        );
+      },
+      writeExitCode: (code: number, error?: Error) => {
+        if (error) {
+          streams.exit.write(`Error: ${error.message}\n`);
+          if (error.stack) {
+            streams.exit.write(`Stack Trace:\n${error.stack}\n`);
+          }
+        }
+        streams.exit.write(`${code}\n`);
+      },
+      exit: streams.exit,
+    };
+  } catch (e) {
+    console.error(`Failed to create log streams in ${safeDest}:`, e);
+    throw e;
+  }
+}
+
 async function fileHash(filePath, algorithm = "md5") {
   return new Promise<string>((resolve, reject) => {
     const hash = crypto.createHash(algorithm);
@@ -63,12 +175,18 @@ const statusMessagePretty = (
   runtime: IRunTime
 ) => {
   if (failures === 0) {
+    console.log(ansiC.green(ansiC.inverse(`${runtime} > ${test}`)));
+  } else if (failures > 0) {
     console.log(
-      ansiC.green(ansiC.inverse(`${runtime} > ${test} completed successfully`))
+      ansiC.red(
+        ansiC.inverse(
+          `${runtime} > ${test} failed ${failures} times (exit code: ${failures})`
+        )
+      )
     );
   } else {
     console.log(
-      ansiC.red(ansiC.inverse(`${runtime} > ${test} failed ${failures} times`))
+      ansiC.red(ansiC.inverse(`${runtime} > ${test} crashed (exit code: -1)`))
     );
   }
 };
@@ -117,14 +235,34 @@ async function pollForFile(path, timeout = 2000) {
 export class PM_Main extends PM_WithEslintAndTsc {
   ports: Record<number, string>;
   queue: string[];
+  logStreams: Record<string, ReturnType<typeof createLogStreams>> = {};
   webMetafileWatcher: fs.FSWatcher;
   nodeMetafileWatcher: fs.FSWatcher;
   importMetafileWatcher: fs.FSWatcher;
   pureSidecars: Record<number, Sidecar>;
   nodeSidecars: Record<number, ChildProcess>;
   webSidecars: Record<number, Page>;
+  sidecars: Record<number, any> = {};
   launchers: Record<string, () => void>;
 
+  wss: WebSocketServer;
+  clients: Set<any> = new Set();
+  httpServer: http.Server;
+  runningProcesses: Map<string, ChildProcess> = new Map();
+  allProcesses: Map<
+    string,
+    {
+      child?: ChildProcess;
+      status: "running" | "exited" | "error";
+      exitCode?: number;
+      error?: string;
+      command: string;
+      pid?: number;
+      timestamp: string;
+    }
+  > = new Map();
+  processLogs: Map<string, string[]> = new Map();
+
   constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev") {
     super(configs, name, mode);
 
@@ -139,6 +277,222 @@ export class PM_Main extends PM_WithEslintAndTsc {
     this.configs.ports.forEach((element) => {
       this.ports[element] = ""; // set ports as open
     });
+
+    // Create HTTP server
+    this.httpServer = http.createServer(this.requestHandler.bind(this));
+
+    // Start WebSocket server attached to the HTTP server
+    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 {
+          const message = JSON.parse(data.toString());
+          if (message.type === "executeCommand") {
+            // Validate the command starts with 'aider'
+            if (message.command && message.command.trim().startsWith("aider")) {
+              console.log(`Executing command: ${message.command}`);
+              // Execute the command
+              const processId = Date.now().toString();
+              const child = spawn(message.command, {
+                shell: true,
+                cwd: process.cwd(),
+              });
+
+              // Track the process in both maps
+              this.runningProcesses.set(processId, child);
+              this.allProcesses.set(processId, {
+                child,
+                status: "running",
+                command: message.command,
+                pid: child.pid,
+                timestamp: new Date().toISOString(),
+              });
+
+              // Initialize logs for this process
+              this.processLogs.set(processId, []);
+
+              // Broadcast process started
+              this.broadcast({
+                type: "processStarted",
+                processId,
+                command: message.command,
+                timestamp: new Date().toISOString(),
+                logs: [],
+              });
+
+              // Capture stdout and stderr
+              child.stdout?.on("data", (data) => {
+                const logData = data.toString();
+                // Add to stored logs
+                const logs = this.processLogs.get(processId) || [];
+                logs.push(logData);
+                this.processLogs.set(processId, logs);
+
+                this.broadcast({
+                  type: "processStdout",
+                  processId,
+                  data: logData,
+                  timestamp: new Date().toISOString(),
+                });
+              });
+
+              child.stderr?.on("data", (data) => {
+                const logData = data.toString();
+                // Add to stored logs
+                const logs = this.processLogs.get(processId) || [];
+                logs.push(logData);
+                this.processLogs.set(processId, logs);
+
+                this.broadcast({
+                  type: "processStderr",
+                  processId,
+                  data: logData,
+                  timestamp: new Date().toISOString(),
+                });
+              });
+
+              child.on("error", (error) => {
+                console.error(`Failed to execute command: ${error}`);
+                this.runningProcesses.delete(processId);
+                // Update the process status to error
+                const processInfo = this.allProcesses.get(processId);
+                if (processInfo) {
+                  this.allProcesses.set(processId, {
+                    ...processInfo,
+                    status: "error",
+                    error: error.message,
+                  });
+                }
+                this.broadcast({
+                  type: "processError",
+                  processId,
+                  error: error.message,
+                  timestamp: new Date().toISOString(),
+                });
+              });
+
+              child.on("exit", (code) => {
+                console.log(`Command exited with code ${code}`);
+                // Remove from running processes but keep in allProcesses
+                this.runningProcesses.delete(processId);
+                // Update the process status to exited
+                const processInfo = this.allProcesses.get(processId);
+                if (processInfo) {
+                  this.allProcesses.set(processId, {
+                    ...processInfo,
+                    status: "exited",
+                    exitCode: code,
+                  });
+                }
+                this.broadcast({
+                  type: "processExited",
+                  processId,
+                  exitCode: code,
+                  timestamp: new Date().toISOString(),
+                });
+              });
+            } else {
+              console.error('Invalid command: must start with "aider"');
+            }
+          } else if (message.type === "getRunningProcesses") {
+            // Send list of all processes (both running and completed) with their full logs
+            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,
+                logs: this.processLogs.get(id) || [],
+              })
+            );
+            ws.send(
+              JSON.stringify({
+                type: "runningProcesses",
+                processes,
+              })
+            );
+          } else if (message.type === "getProcess") {
+            // Send specific process with full logs
+            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,
+                  logs: this.processLogs.get(processId) || [],
+                })
+              );
+            }
+          } else if (message.type === "stdin") {
+            // Handle stdin input for a process
+            const processId = message.processId;
+            const data = message.data;
+            console.log("Received stdin for process", processId, ":", data);
+            const childProcess = this.runningProcesses.get(processId);
+
+            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") {
+            // Handle killing a process
+            const processId = message.processId;
+            console.log("Received killProcess for process", processId);
+            const childProcess = this.runningProcesses.get(processId);
+
+            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,
+              });
+            }
+          }
+        } 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);
+      });
+    });
+
+    // Start HTTP server
+    const httpPort = Number(process.env.HTTP_PORT) || 3000;
+    this.httpServer.listen(httpPort, () => {
+      console.log(`HTTP server running on http://localhost:${httpPort}`);
+    });
   }
 
   async stopSideCar(uid: number): Promise<any> {
@@ -243,17 +597,18 @@ export class PM_Main extends PM_WithEslintAndTsc {
         waitForInitialPage: false,
         executablePath,
         headless: true,
+        defaultViewport: null, // Disable default 800x600 viewport
         dumpio: false,
         devtools: false,
 
         args: [
-          "--disable-features=site-per-process",
           "--allow-file-access-from-files",
           "--allow-insecure-localhost",
           "--allow-running-insecure-content",
           "--auto-open-devtools-for-tabs",
           "--disable-dev-shm-usage",
           "--disable-extensions",
+          "--disable-features=site-per-process",
           "--disable-gpu",
           "--disable-setuid-sandbox",
           "--disable-site-isolation-trials",
@@ -263,6 +618,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
           "--no-startup-window",
           "--reduce-security-for-testing",
           "--remote-allow-origins=*",
+          "--start-maximized",
           "--unsafely-treat-insecure-origin-as-secure=*",
           `--remote-debugging-port=3234`,
           // "--disable-features=IsolateOrigins,site-per-process",
@@ -320,7 +676,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
         IRunTime,
         (f: fs.FSWatcher) => void
       ]) => {
-        const metafile = `./testeranto/bundles/${runtime}/${this.name}/metafile.json`;
+        const metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
 
         await pollForFile(metafile);
 
@@ -404,6 +760,26 @@ export class PM_Main extends PM_WithEslintAndTsc {
     this.nodeMetafileWatcher.close();
     this.webMetafileWatcher.close();
     this.importMetafileWatcher.close();
+
+    // Close any remaining log streams
+    Object.values(this.logStreams || {}).forEach((logs) => logs.closeAll());
+
+    // Close WebSocket server
+    this.wss.close(() => {
+      console.log("WebSocket server closed");
+    });
+
+    // Close all client connections
+    this.clients.forEach((client) => {
+      client.terminate();
+    });
+    this.clients.clear();
+
+    // Close HTTP server
+    this.httpServer.close(() => {
+      console.log("HTTP server closed");
+    });
+
     this.checkForShutdown();
   }
 
@@ -425,9 +801,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
   async metafileOutputs(platform: IRunTime) {
     const metafile = JSON.parse(
       fs
-        .readFileSync(
-          `./testeranto/bundles/${platform}/${this.name}/metafile.json`
-        )
+        .readFileSync(`./testeranto/metafiles/${platform}/${this.name}.json`)
         .toString()
     ).metafile;
 
@@ -533,7 +907,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
         });
       } else {
         this.queue.push(src);
-        return;
+        return [Math.random(), argz];
       }
     } else {
       console.error("negative port makes no sense", src);
@@ -571,8 +945,24 @@ export class PM_Main extends PM_WithEslintAndTsc {
     //   })
     // );
 
+    const logs = createLogStreams(reportDest, "pure");
+
     try {
       await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+        // Override console methods to redirect logs
+        // Only override stdout/stderr methods for pure runtime
+        const originalConsole = { ...console };
+
+        // console.log = (...args) => {
+        //   logs.stdout.write(args.join(" ") + "\n");
+        //   originalConsole.log(...args);
+        // };
+
+        // console.error = (...args) => {
+        //   logs.stderr.write(args.join(" ") + "\n");
+        //   originalConsole.error(...args);
+        // };
+
         return module.default
           .then((defaultModule) => {
             defaultModule
@@ -586,7 +976,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
               })
               .catch((e1) => {
                 console.log(
-                  ansiC.red(`launchPure - ${src} errored with: ${e1}`)
+                  ansiC.red(`launchPure - ${src} errored with: ${e1.stack}`)
                 );
                 this.bddTestIsNowDone(src, -1);
                 statusMessagePretty(-1, src, "pure");
@@ -598,11 +988,12 @@ export class PM_Main extends PM_WithEslintAndTsc {
           .catch((e2) => {
             console.log(
               ansiColors.red(
-                `pure ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/logs.txt for more info`
+                `pure ! ${src} failed to execute. No "tests.json" file was generated. Check the logs for more info`
               )
             );
 
-            this.writeFileSync(`${reportDest}/logs.txt`, e2.stack, src);
+            logs.exit.write(e2.stack);
+            logs.exit.write(-1);
             this.bddTestIsNowDone(src, -1);
             statusMessagePretty(-1, src, "pure");
             // console.error(e);
@@ -616,17 +1007,19 @@ export class PM_Main extends PM_WithEslintAndTsc {
           });
       });
     } catch (e3) {
+      logs.writeExitCode(-1, e3);
       console.log(
         ansiC.red(
           ansiC.inverse(
-            `${src} 1 errored with: ${e3}. Check ${reportDest}/logs.txt for more info`
+            `${src} 1 errored with: ${e3}. Check logs for more info`
           )
         )
       );
-      this.writeFileSync(`${reportDest}/logs.txt`, e3.stack, src);
+
+      logs.exit.write(e3.stack);
+      logs.exit.write(-1);
       this.bddTestIsNowDone(src, -1);
       statusMessagePretty(-1, src, "pure");
-      console.log("III) PURE IS EXITING BADLY WITH error", e3);
     }
 
     for (let i = 0; i <= portsToUse.length; i++) {
@@ -644,7 +1037,6 @@ export class PM_Main extends PM_WithEslintAndTsc {
       .split(".")
       .slice(0, -1)
       .join(".")}/node`;
-
     if (!fs.existsSync(reportDest)) {
       fs.mkdirSync(reportDest, { recursive: true });
     }
@@ -683,7 +1075,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
       if (openPorts.length >= testConfigResource.ports) {
         for (let i = 0; i < testConfigResource.ports; i++) {
-          portsToUse.push(openPorts[i][0]);
+          portsToUse.push(openPorts[i][0]); // Convert string port to number
 
           this.ports[openPorts[i][0]] = src; // port is now claimed
         }
@@ -702,7 +1094,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
           )
         );
         this.queue.push(src);
-        return;
+        return [Math.random(), argz]; // Add this return
       }
     } else {
       console.error("negative port makes no sense", src);
@@ -775,52 +1167,50 @@ export class PM_Main extends PM_WithEslintAndTsc {
       });
     });
 
-    const oStream = fs.createWriteStream(`${reportDest}/logs.txt`);
-
-    const errFile = `${reportDest}/logs.txt`;
-
-    if (fs.existsSync(errFile)) {
-      fs.rmSync(errFile);
-    }
+    const logs = createLogStreams(reportDest, "node");
 
     server.listen(ipcfile, () => {
-      child.stderr?.on("data", (data) => {
-        oStream.write(`stderr > ${data}`);
-      });
+      // Only handle stdout/stderr for node runtime
       child.stdout?.on("data", (data) => {
-        oStream.write(`stdout > ${data}`);
+        logs.stdout?.write(data); // Add null check
+      });
+
+      child.stderr?.on("data", (data) => {
+        logs.stderr?.write(data); // Add null check
       });
       child.on("error", (err) => {});
       child.on("close", (code) => {
-        // oStream.close();
+        const exitCode = code === null ? -1 : code;
+        if (exitCode < 0) {
+          logs.writeExitCode(
+            exitCode,
+            new Error("Process crashed or was terminated")
+          );
+        } else {
+          logs.writeExitCode(exitCode);
+        }
+        logs.closeAll();
         server.close();
 
         if (!files[src]) {
           files[src] = new Set();
         }
-        // files[src].add(filepath);
-
-        // fs.writeFileSync(
-        //   reportDest + "/manifest.json",
-        //   JSON.stringify(Array.from(files[src]))
-        // );
 
-        if (code === 255) {
+        if (exitCode === 255) {
           console.log(
             ansiColors.red(
-              `node ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/logs.txt for more info`
+              `node ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/stderr.log for more info`
             )
           );
           this.bddTestIsNowDone(src, -1);
           statusMessagePretty(-1, src, "node");
-          oStream.close();
           return;
-        } else if (code === 0) {
+        } else if (exitCode === 0) {
           this.bddTestIsNowDone(src, 0);
           statusMessagePretty(0, src, "node");
         } else {
-          this.bddTestIsNowDone(src, code);
-          statusMessagePretty(code, src, "node");
+          this.bddTestIsNowDone(src, exitCode);
+          statusMessagePretty(exitCode, src, "node");
         }
 
         haltReturns = true;
@@ -842,11 +1232,10 @@ export class PM_Main extends PM_WithEslintAndTsc {
         console.log(
           ansiC.red(
             ansiC.inverse(
-              `${src} errored with: ${e.name}. Check ${errFile} for more info`
+              `${src} errored with: ${e.name}. Check error logs for more info`
             )
           )
         );
-        this.writeFileSync(`${reportDest}/logs.txt`, e.toString(), src);
         this.bddTestIsNowDone(src, -1);
         statusMessagePretty(-1, src, "node");
       });
@@ -855,7 +1244,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
   launchWebSideCar = async (
     testConfig: ITestTypes
-  ): Promise<[number, ITTestResourceConfiguration]> => {
+  ): Promise<[number, Page]> => {
     const src = testConfig[0];
     const dest = src.split(".").slice(0, -1).join(".");
     // const d = dest + ".mjs";
@@ -864,10 +1253,10 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
     console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
 
-    const fileStreams2: fs.WriteStream[] = [];
-    const doneFileStream2: Promise<any>[] = [];
+    // const fileStreams2: fs.WriteStream[] = [];
+    // const doneFileStream2: Promise<any>[] = [];
 
-    const oStream = fs.createWriteStream(`${destFolder}/logs.txt`);
+    const logs = createLogStreams(dest, "web");
 
     return new Promise((res, rej) => {
       this.browser
@@ -893,40 +1282,43 @@ export class PM_Main extends PM_WithEslintAndTsc {
             Promise.all(screenshots[src] || []).then(() => {
               delete screenshots[src];
               page.close();
-              oStream.close();
             });
           };
 
           page.on("pageerror", (err: Error) => {
             console.debug(`Error from ${src}: [${err.name}] `);
-            oStream.write(err.name);
-            oStream.write("\n");
-
+            console.debug(`Error from ${src}: [${err.name}] `);
             if (err.cause) {
               console.debug(`Error from ${src} cause: [${err.cause}] `);
-              oStream.write(err.cause);
-              oStream.write("\n");
             }
-
             if (err.stack) {
               console.debug(`Error from stack ${src}: [${err.stack}] `);
-              oStream.write(err.stack);
-              oStream.write("\n");
             }
-
             console.debug(`Error from message ${src}: [${err.message}] `);
-            oStream.write(err.message);
-            oStream.write("\n");
-
             this.bddTestIsNowDone(src, -1);
             close();
           });
 
           page.on("console", (log: ConsoleMessage) => {
-            oStream.write(log.text());
-            oStream.write(JSON.stringify(log.location()));
-            oStream.write(JSON.stringify(log.stackTrace()));
-            oStream.write("\n");
+            const msg = `${log.text()}\n${JSON.stringify(
+              log.location()
+            )}\n${JSON.stringify(log.stackTrace())}\n`;
+            switch (log.type()) {
+              case "info":
+                logs.info?.write(msg);
+                break;
+              case "warn":
+                logs.warn?.write(msg);
+                break;
+              case "error":
+                logs.error?.write(msg);
+                break;
+              case "debug":
+                logs.debug?.write(msg);
+                break;
+              default:
+                break;
+            }
           });
 
           await page.goto(`file://${`${destFolder}.html`}`, {});
@@ -978,7 +1370,6 @@ export class PM_Main extends PM_WithEslintAndTsc {
         .then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
 
-          /* @ts-ignore:next-line */
           res([Math.random(), page]);
         });
     });
@@ -1009,6 +1400,8 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
     const testReq: { ports: number } = sidecar[2];
 
+    const logs = createLogStreams(dest, "node");
+
     const portsToUse: number[] = [];
     if (testReq.ports === 0) {
       // argz = {
@@ -1024,7 +1417,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
       if (openPorts.length >= testReq.ports) {
         for (let i = 0; i < testReq.ports; i++) {
-          portsToUse.push(openPorts[i][0]);
+          portsToUse.push(Number(openPorts[i][0])); // Convert string port to number
 
           this.ports[openPorts[i][0]] = src; // port is now closed
         }
@@ -1076,8 +1469,6 @@ export class PM_Main extends PM_WithEslintAndTsc {
           });
         });
 
-        const oStream = fs.createWriteStream(`${reportDest}/logs.txt`);
-
         const child = spawn("node", [builtfile, JSON.stringify(argz)], {
           stdio: ["pipe", "pipe", "pipe", "ipc"],
           // silent: true
@@ -1085,19 +1476,9 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
         const p = "/tmp/tpipe" + Math.random();
 
-        const errFile = `${reportDest}/logs.txt`;
-
         server.listen(p, () => {
-          child.stderr?.on("data", (data) => {
-            oStream.write(`stderr > ${data}`);
-          });
-          child.stdout?.on("data", (data) => {
-            oStream.write(`stdout > ${data}`);
-          });
           child.on("close", (code) => {
-            oStream.close();
             server.close();
-
             haltReturns = true;
           });
           child.on("exit", (code) => {
@@ -1119,11 +1500,11 @@ export class PM_Main extends PM_WithEslintAndTsc {
             console.log(
               ansiC.red(
                 ansiC.inverse(
-                  `launchNodeSideCar - ${src} errored with: ${e.name}. Check ${errFile}for more info`
+                  `launchNodeSideCar - ${src} errored with: ${e.name}. Check logs for more info`
                 )
               )
             );
-            this.writeFileSync(`${reportDest}/logs.txt`, e.toString(), src);
+            logs.error?.write(e.toString() + "\n");
             // this.bddTestIsNowDone(src, -1);
             // statusMessagePretty(-1, src);
           });
@@ -1190,7 +1571,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
       );
       if (openPorts.length >= testConfigResource.ports) {
         for (let i = 0; i < testConfigResource.ports; i++) {
-          portsToUse.push(openPorts[i][0]);
+          portsToUse.push(Number(openPorts[i][0]));
 
           this.ports[openPorts[i][0]] = src; // port is now claimed
         }
@@ -1205,7 +1586,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
         };
       } else {
         this.queue.push(src);
-        return;
+        // return;
       }
     } else {
       console.error("negative port makes no sense", src);
@@ -1215,6 +1596,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
     // const builtfile = dest + ".mjs";
 
     await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+      if (!this.pureSidecars) this.pureSidecars = {};
       this.pureSidecars[r] = module.default;
       this.pureSidecars[r].start(argz);
     });
@@ -1250,12 +1632,37 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
     const d = `${dest}?cacheBust=${Date.now()}`;
 
-    const ofile = `${reportDest}/logs.txt`;
-    const oStream = fs.createWriteStream(ofile);
+    const logs = createLogStreams(reportDest, "web");
 
     this.browser
       .newPage()
       .then((page) => {
+        page.on("console", (log: ConsoleMessage) => {
+          const msg = `${log.text()}\n`;
+
+          switch (log.type()) {
+            case "info":
+              logs.info?.write(msg);
+              break;
+            case "warn":
+              logs.warn?.write(msg);
+              break;
+            case "error":
+              logs.error?.write(msg);
+              break;
+            case "debug":
+              logs.debug?.write(msg);
+              break;
+            default:
+              break;
+          }
+        });
+
+        page.on("close", () => {
+          logs.writeExitCode(0); // Web tests exit with 0 unless there's an error
+          logs.closeAll();
+          logs.closeAll();
+        });
         this.mapping().forEach(async ([command, func]) => {
           if (command === "page") {
             page.exposeFunction(command, (x?) => {
@@ -1288,55 +1695,23 @@ export class PM_Main extends PM_WithEslintAndTsc {
           Promise.all(screenshots[src] || []).then(() => {
             delete screenshots[src];
             page.close();
-            oStream.close();
           });
 
           return;
         };
 
         page.on("pageerror", (err: Error) => {
+          logs.writeExitCode(-1, err);
           console.log(
             ansiColors.red(
-              `web ! ${src} failed to execute No "tests.json" file was generated. Check ${reportDest}/logs.txt for more info`
+              `web ! ${src} failed to execute No "tests.json" file was generated. Check ${reportDest}/error.log for more info`
             )
           );
-
-          oStream.write(err.name);
-          oStream.write("\n");
-
-          if (err.cause) {
-            oStream.write(err.cause);
-            oStream.write("\n");
-          }
-
-          if (err.stack) {
-            oStream.write(err.stack);
-            oStream.write("\n");
-          }
-
-          if (err.message) {
-            oStream.write(err.message);
-            oStream.write("\n");
-          }
-
           this.bddTestIsNowDone(src, -1);
           close();
         });
 
-        page.on("console", (log: ConsoleMessage) => {
-          // console.log("console message: ", log.text());
-          if (oStream.closed) {
-            console.log("missed console message: ", log.text());
-            return;
-          } else {
-            oStream.write(log.text());
-            oStream.write("\n");
-            oStream.write(JSON.stringify(log.location()));
-            oStream.write("\n");
-            oStream.write(JSON.stringify(log.stackTrace()));
-            oStream.write("\n");
-          }
-        });
+        // page.on("console", (log: ConsoleMessage) => {});
 
         await page.goto(`file://${`${destFolder}.html`}`, {});
 
@@ -1363,7 +1738,7 @@ import('${d}').then(async (x) => {
             console.log(
               ansiC.red(
                 ansiC.inverse(
-                  `web ! ${src} failed to execute. No "tests.json" file was generated. Check ${reportDest}/logs.txt for more info`
+                  `web ! ${src} failed to execute. No "tests.json" file was generated. Check logs for more info`
                 )
               )
             );
@@ -1391,9 +1766,28 @@ import('${d}').then(async (x) => {
       srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
     );
 
-    const testReport = JSON.parse(
-      fs.readFileSync(`${reportDest}/tests.json`).toString()
-    );
+    // Read and parse the test report
+    const testReportPath = `${reportDest}/tests.json`;
+    if (!fs.existsSync(testReportPath)) {
+      console.error(`tests.json not found at: ${testReportPath}`);
+      return;
+    }
+
+    const testReport = JSON.parse(fs.readFileSync(testReportPath, "utf8"));
+
+    // Add full path information to each test
+    if (testReport.tests) {
+      testReport.tests.forEach((test) => {
+        // Add the full path to each test
+        test.fullPath = path.resolve(process.cwd(), srcTest);
+      });
+    }
+
+    // Add full path to the report itself
+    testReport.fullPath = path.resolve(process.cwd(), srcTest);
+
+    // Write the modified report back
+    fs.writeFileSync(testReportPath, JSON.stringify(testReport, null, 2));
 
     testReport.features
       .reduce(async (mm, featureStringKey) => {
@@ -1451,7 +1845,7 @@ import('${d}').then(async (x) => {
       }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
 
       .then(({ files, strings }: { files: string[]; strings: string[] }) => {
-        // Markdown files must be referenced in the prompt but string style features are already present in the test.json file
+        // Markdown files must be referenced in the prompt but string style features are already present in the tests.json file
 
         fs.writeFileSync(
           `testeranto/reports/${this.name}/${srcTest
@@ -1478,6 +1872,151 @@ import('${d}').then(async (x) => {
     this.writeBigBoard();
   };
 
+  requestHandler(req: http.IncomingMessage, res: http.ServerResponse) {
+    // Parse the URL
+    const parsedUrl = url.parse(req.url || "/");
+    let pathname = parsedUrl.pathname || "/";
+
+    // Handle root path
+    if (pathname === "/") {
+      pathname = "/index.html";
+    }
+
+    // Remove leading slash
+    let filePath = pathname.substring(1);
+
+    // Determine which directory to serve from
+    if (filePath.startsWith("reports/")) {
+      // Serve from reports directory
+      filePath = `testeranto/${filePath}`;
+    } else if (filePath.startsWith("metafiles/")) {
+      // Serve from metafiles directory
+      filePath = `testeranto/${filePath}`;
+    } else if (filePath === "projects.json") {
+      // Serve projects.json
+      filePath = `testeranto/${filePath}`;
+    } else {
+      // For frontend assets, try multiple possible locations
+      // First, try the dist directory
+      const possiblePaths = [
+        `dist/${filePath}`,
+        `testeranto/dist/${filePath}`,
+        `../dist/${filePath}`,
+        `./${filePath}`,
+      ];
+
+      // Find the first existing file
+      let foundPath = null;
+      for (const possiblePath of possiblePaths) {
+        if (fs.existsSync(possiblePath)) {
+          foundPath = possiblePath;
+          break;
+        }
+      }
+
+      if (foundPath) {
+        filePath = foundPath;
+      } else {
+        // If no file found, serve index.html for SPA routing
+        const indexPath = this.findIndexHtml();
+        if (indexPath) {
+          fs.readFile(indexPath, (err, data) => {
+            if (err) {
+              res.writeHead(404, { "Content-Type": "text/plain" });
+              res.end("404 Not Found");
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(data);
+          });
+          return;
+        } else {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("404 Not Found");
+          return;
+        }
+      }
+    }
+
+    // Check if file exists
+    fs.exists(filePath, (exists) => {
+      if (!exists) {
+        // For SPA routing, serve index.html if the path looks like a route
+        if (!pathname.includes(".") && pathname !== "/") {
+          const indexPath = this.findIndexHtml();
+          if (indexPath) {
+            fs.readFile(indexPath, (err, data) => {
+              if (err) {
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("404 Not Found");
+                return;
+              }
+              res.writeHead(200, { "Content-Type": "text/html" });
+              res.end(data);
+            });
+            return;
+          } else {
+            // Serve a simple message if index.html is not found
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(`
+              <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;
+          }
+        }
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("404 Not Found");
+        return;
+      }
+
+      // Read and serve the file
+      fs.readFile(filePath, (err, data) => {
+        if (err) {
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("500 Internal Server Error");
+          return;
+        }
+
+        // Get MIME type
+        const mimeType = mime.lookup(filePath) || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": mimeType });
+        res.end(data);
+      });
+    });
+  }
+
+  findIndexHtml(): string | null {
+    const possiblePaths = [
+      "dist/index.html",
+      "testeranto/dist/index.html",
+      "../dist/index.html",
+      "./index.html",
+    ];
+
+    for (const path of possiblePaths) {
+      if (fs.existsSync(path)) {
+        return path;
+      }
+    }
+    return null;
+  }
+
+  broadcast(message: any) {
+    const data =
+      typeof message === "string" ? message : JSON.stringify(message);
+    this.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        // WebSocket.OPEN
+        client.send(data);
+      }
+    });
+  }
+
   checkQueue() {
     const x = this.queue.pop();
     if (!x) {
@@ -1544,10 +2083,16 @@ import('${d}').then(async (x) => {
     this.writeBigBoard();
 
     if (!inflight) {
-      this.browser.disconnect().then(() => {
-        console.log(ansiC.inverse(`${this.name} has been tested. Goodbye.`));
-        process.exit();
-      });
+      if (this.browser) {
+        if (this.browser) {
+          this.browser.disconnect().then(() => {
+            console.log(
+              ansiC.inverse(`${this.name} has been tested. Goodbye.`)
+            );
+            process.exit();
+          });
+        }
+      }
     }
   };
 }