testeranto 0.177.0 → 0.197.0

package/dist/prebuild/run.mjs

@@ -8,11 +8,15 @@ import readline from "readline";
 import { spawn } from "node:child_process";
 import ansiColors from "ansi-colors";
 import net from "net";
-import fs3, { watch } from "fs";
+import fs4, { watch } from "fs";
 import path4 from "path";
 import puppeteer from "puppeteer-core";
 import ansiC2 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";
 
 // src/utils.ts
 import path from "path";
@@ -123,8 +127,7 @@ var Queue = class {
 
 // src/PM/PM_WithEslintAndTsc.ts
 import ts from "typescript";
-import fs2 from "fs";
-import path3 from "path";
+import fs3 from "fs";
 import ansiC from "ansi-colors";
 import { ESLint } from "eslint";
 import tsc from "tsc-prog";
@@ -164,10 +167,10 @@ var PM_Base = class {
   async newPage() {
     return (await this.browser.newPage()).mainFrame()._id;
   }
-  goto(p, url) {
+  goto(p, url2) {
     return new Promise((res) => {
       this.doInPage(p, async (page) => {
-        await page?.goto(url);
+        await page?.goto(url2);
         res({});
       });
     });
@@ -250,7 +253,6 @@ var PM_Base = class {
     const filepath = x[0];
     const contents = x[1];
     const testName = x[2];
-    console.log("writing file", filepath);
     return new Promise(async (res) => {
       fs.mkdirSync(path2.dirname(filepath), {
         recursive: true
@@ -390,6 +392,142 @@ var PM_Base = class {
   }
 };
 
+// src/utils/makePrompt.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/utils/logFiles.ts
+var LOG_FILES = {
+  TESTS: "tests.json",
+  TYPE_ERRORS: "type_errors.txt",
+  LINT_ERRORS: "lint_errors.txt",
+  EXIT: "exit.log",
+  MESSAGE: "message.txt",
+  PROMPT: "prompt.txt",
+  STDOUT: "stdout.log",
+  STDERR: "stderr.log",
+  INFO: "info.log",
+  ERROR: "error.log",
+  WARN: "warn.log",
+  DEBUG: "debug.log"
+};
+var STANDARD_LOGS = {
+  TESTS: "tests.json",
+  TYPE_ERRORS: "type_errors.txt",
+  LINT_ERRORS: "lint_errors.txt",
+  EXIT: "exit.log",
+  MESSAGE: "message.txt",
+  PROMPT: "prompt.txt"
+};
+var RUNTIME_SPECIFIC_LOGS = {
+  node: {
+    STDOUT: "stdout.log",
+    STDERR: "stderr.log"
+  },
+  web: {
+    INFO: "info.log",
+    ERROR: "error.log",
+    WARN: "warn.log",
+    DEBUG: "debug.log"
+  },
+  pure: {}
+  // No runtime-specific logs for pure
+};
+var ALL_LOGS = {
+  ...STANDARD_LOGS,
+  ...Object.values(RUNTIME_SPECIFIC_LOGS).reduce((acc, logs) => ({ ...acc, ...logs }), {})
+};
+var getRuntimeLogs = (runtime) => {
+  return {
+    standard: Object.values(STANDARD_LOGS),
+    runtimeSpecific: Object.values(RUNTIME_SPECIFIC_LOGS[runtime])
+  };
+};
+function getLogFilesForRuntime(runtime) {
+  const { standard, runtimeSpecific } = getRuntimeLogs(runtime);
+  return [...standard, ...runtimeSpecific];
+}
+
+// src/utils/makePrompt.ts
+var makePrompt = async (summary, name, entryPoint, addableFiles, runtime) => {
+  summary[entryPoint].prompt = "?";
+  const promptPath = promptPather(entryPoint, runtime, name);
+  const testDir = path3.join(
+    "testeranto",
+    "reports",
+    name,
+    entryPoint.split(".").slice(0, -1).join("."),
+    runtime
+  );
+  if (!fs2.existsSync(testDir)) {
+    fs2.mkdirSync(testDir, { recursive: true });
+  }
+  const testPaths = path3.join(testDir, LOG_FILES.TESTS);
+  const lintPath = path3.join(testDir, LOG_FILES.LINT_ERRORS);
+  const typePath = path3.join(testDir, LOG_FILES.TYPE_ERRORS);
+  const messagePath = path3.join(testDir, LOG_FILES.MESSAGE);
+  try {
+    await Promise.all([
+      fs2.promises.writeFile(
+        promptPath,
+        `
+${addableFiles.map((x) => {
+          return `/add ${x}`;
+        }).join("\n")}
+
+/read node_modules/testeranto/docs/index.md
+/read node_modules/testeranto/docs/style.md
+/read node_modules/testeranto/docs/testing.ai.txt
+/read node_modules/testeranto/src/CoreTypes.ts
+
+/read ${testPaths}
+/read ${typePath}
+/read ${lintPath}
+
+/read ${getLogFilesForRuntime(runtime).map((p) => `${testDir}/${p}`).join(" ")}
+`
+      ),
+      fs2.promises.writeFile(
+        messagePath,
+        `
+There are 3 types of test reports.
+1) bdd (highest priority)
+2) type checker
+3) static analysis (lowest priority)
+
+"tests.json" is the detailed result of the bdd tests.
+if these files do not exist, then something has gone badly wrong and needs to be addressed.
+
+"type_errors.txt" is the result of the type checker.
+if this file does not exist, then type check passed without errors;
+
+"lint_errors.txt" is the result of the static analysis.
+if this file does not exist, then static analysis passed without errors;
+
+BDD failures are the highest priority. Focus on passing BDD tests before addressing other concerns.
+Do not add error throwing/catching to the tests themselves.
+`
+      )
+    ]);
+  } catch (e) {
+    console.error(`Failed to write prompt files at ${testDir}`);
+    console.error(e);
+    throw e;
+  }
+  summary[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${name}/reports/${runtime}/${entryPoint.split(".").slice(0, -1).join(".")}/prompt.txt`;
+};
+var makePromptInternal = (summary, name, entryPoint, addableFiles, runTime) => {
+  if (runTime === "node") {
+    return makePrompt(summary, name, entryPoint, addableFiles, "node");
+  }
+  if (runTime === "web") {
+    return makePrompt(summary, name, entryPoint, addableFiles, "web");
+  }
+  if (runTime === "pure") {
+    return makePrompt(summary, name, entryPoint, addableFiles, "pure");
+  }
+};
+
 // src/PM/PM_WithEslintAndTsc.ts
 var eslint = new ESLint();
 var formatter = await eslint.loadFormatter(
@@ -452,7 +590,7 @@ var PM_WithEslintAndTsc = class extends PM_Base {
           );
         }
       });
-      fs2.writeFileSync(tscPath, results.join("\n"));
+      fs3.writeFileSync(tscPath, results.join("\n"));
       this.typeCheckIsNowDone(entrypoint, results.length);
     };
     this.eslintCheck = async (entrypoint, platform, addableFiles) => {
@@ -467,93 +605,25 @@ var PM_WithEslintAndTsc = class extends PM_Base {
         process.exit(-1);
       }
       const filepath = lintPather(entrypoint, platform, this.name);
-      if (fs2.existsSync(filepath))
-        fs2.rmSync(filepath);
+      if (fs3.existsSync(filepath))
+        fs3.rmSync(filepath);
       const results = (await eslint.lintFiles(addableFiles)).filter((r) => r.messages.length).filter((r) => {
         return r.messages[0].ruleId !== null;
       }).map((r) => {
         delete r.source;
         return r;
       });
-      fs2.writeFileSync(filepath, await formatter.format(results));
+      fs3.writeFileSync(filepath, await formatter.format(results));
       this.lintIsNowDone(entrypoint, results.length);
     };
     this.makePrompt = async (entryPoint, addableFiles, platform) => {
-      this.summary[entryPoint].prompt = "?";
-      const promptPath = promptPather(entryPoint, platform, this.name);
-      const testPaths = path3.join(
-        "testeranto",
-        "reports",
-        this.name,
-        entryPoint.split(".").slice(0, -1).join("."),
-        platform,
-        `tests.json`
-      );
-      const featuresPath = path3.join(
-        "testeranto",
-        "reports",
-        this.name,
-        platform,
-        entryPoint.split(".").slice(0, -1).join("."),
-        `featurePrompt.txt`
-      );
-      const logPath = path3.join(
-        "testeranto",
-        "reports",
+      await makePromptInternal(
+        this.summary,
         this.name,
-        entryPoint.split(".").slice(0, -1).join("."),
-        platform,
-        `logs.txt`
+        entryPoint,
+        addableFiles,
+        platform
       );
-      const lintPath = path3.join(
-        "testeranto",
-        "reports",
-        this.name,
-        entryPoint.split(".").slice(0, -1).join("."),
-        platform,
-        `lint_errors.txt`
-      );
-      const typePath = path3.join(
-        "testeranto",
-        "reports",
-        this.name,
-        entryPoint.split(".").slice(0, -1).join("."),
-        platform,
-        `type_errors.txt`
-      );
-      const messagePath = path3.join(
-        "testeranto",
-        "reports",
-        this.name,
-        entryPoint.split(".").slice(0, -1).join("."),
-        platform,
-        `message.txt`
-      );
-      fs2.writeFileSync(
-        promptPath,
-        `
-${addableFiles.map((x) => {
-          return `/add ${x}`;
-        }).join("\n")}
-
-/read node_modules/testeranto/docs/index.md
-/read node_modules/testeranto/docs/style.md
-/read node_modules/testeranto/docs/testing.ai.txt
-/read node_modules/testeranto/src/CoreTypes.ts
-
-/read ${testPaths}
-/read ${logPath}
-/read ${typePath}
-/read ${lintPath}
-`
-      );
-      fs2.writeFileSync(
-        messagePath,
-        `
-Fix the failing tests described in ${testPaths} and ${logPath}. Focus on the bdd tests before all other concerns. You may add any debugging you think is necessary.
-`
-      );
-      this.summary[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${this.name}/reports/${platform}/${entryPoint.split(".").slice(0, -1).join(".")}/prompt.txt`;
       this.checkForShutdown();
     };
     this.typeCheckIsRunning = (src) => {
@@ -615,10 +685,13 @@ Fix the failing tests described in ${testPaths} and ${logPath}. Focus on the bdd
       this.checkForShutdown();
     };
     this.writeBigBoard = () => {
-      fs2.writeFileSync(
-        `./testeranto/reports/${this.name}/summary.json`,
-        JSON.stringify(this.summary, null, 2)
-      );
+      const summaryPath = `./testeranto/reports/${this.name}/summary.json`;
+      const summaryData = JSON.stringify(this.summary, null, 2);
+      fs3.writeFileSync(summaryPath, summaryData);
+      this.broadcast({
+        type: "summaryUpdate",
+        data: this.summary
+      });
     };
     this.name = name;
     this.mode = mode2;
@@ -651,10 +724,80 @@ var changes = {};
 var fileHashes = {};
 var files2 = {};
 var screenshots2 = {};
+function runtimeLogs(runtime, reportDest) {
+  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+  try {
+    if (!fs4.existsSync(safeDest)) {
+      fs4.mkdirSync(safeDest, { recursive: true });
+    }
+    if (runtime === "node") {
+      return {
+        stdout: fs4.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs4.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs4.createWriteStream(`${safeDest}/exit.log`)
+      };
+    } else if (runtime === "web") {
+      return {
+        info: fs4.createWriteStream(`${safeDest}/info.log`),
+        warn: fs4.createWriteStream(`${safeDest}/warn.log`),
+        error: fs4.createWriteStream(`${safeDest}/error.log`),
+        debug: fs4.createWriteStream(`${safeDest}/debug.log`),
+        exit: fs4.createWriteStream(`${safeDest}/exit.log`)
+      };
+    } else if (runtime === "pure") {
+      return {
+        exit: fs4.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, runtime) {
+  if (!fs4.existsSync(reportDest)) {
+    fs4.mkdirSync(reportDest, { recursive: true });
+  }
+  const streams = runtimeLogs(runtime, reportDest);
+  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+  try {
+    if (!fs4.existsSync(safeDest)) {
+      fs4.mkdirSync(safeDest, { recursive: true });
+    }
+    const streams2 = runtimeLogs(runtime, safeDest);
+    return {
+      ...streams2,
+      closeAll: () => {
+        Object.values(streams2).forEach(
+          (stream) => !stream.closed && stream.close()
+        );
+      },
+      writeExitCode: (code, error) => {
+        if (error) {
+          streams2.exit.write(`Error: ${error.message}
+`);
+          if (error.stack) {
+            streams2.exit.write(`Stack Trace:
+${error.stack}
+`);
+          }
+        }
+        streams2.exit.write(`${code}
+`);
+      },
+      exit: streams2.exit
+    };
+  } catch (e) {
+    console.error(`Failed to create log streams in ${safeDest}:`, e);
+    throw e;
+  }
+}
 async function fileHash(filePath, algorithm = "md5") {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash(algorithm);
-    const fileStream = fs3.createReadStream(filePath);
+    const fileStream = fs4.createReadStream(filePath);
     fileStream.on("data", (data) => {
       hash.update(data);
     });
@@ -669,20 +812,26 @@ async function fileHash(filePath, algorithm = "md5") {
 }
 var statusMessagePretty = (failures, test, runtime) => {
   if (failures === 0) {
+    console.log(ansiC2.green(ansiC2.inverse(`${runtime} > ${test}`)));
+  } else if (failures > 0) {
     console.log(
-      ansiC2.green(ansiC2.inverse(`${runtime} > ${test} completed successfully`))
+      ansiC2.red(
+        ansiC2.inverse(
+          `${runtime} > ${test} failed ${failures} times (exit code: ${failures})`
+        )
+      )
     );
   } else {
     console.log(
-      ansiC2.red(ansiC2.inverse(`${runtime} > ${test} failed ${failures} times`))
+      ansiC2.red(ansiC2.inverse(`${runtime} > ${test} crashed (exit code: -1)`))
     );
   }
 };
 async function writeFileAndCreateDir(filePath, data) {
   const dirPath = path4.dirname(filePath);
   try {
-    await fs3.promises.mkdir(dirPath, { recursive: true });
-    await fs3.writeFileSync(filePath, data);
+    await fs4.promises.mkdir(dirPath, { recursive: true });
+    await fs4.writeFileSync(filePath, data);
   } catch (error) {
     console.error(`Error writing file: ${error}`);
   }
@@ -707,7 +856,7 @@ function isValidUrl(string) {
 async function pollForFile(path5, timeout = 2e3) {
   const intervalObj = setInterval(function() {
     const file = path5;
-    const fileExists = fs3.existsSync(file);
+    const fileExists = fs4.existsSync(file);
     if (fileExists) {
       clearInterval(intervalObj);
     }
@@ -716,6 +865,12 @@ async function pollForFile(path5, timeout = 2e3) {
 var PM_Main = class extends PM_WithEslintAndTsc {
   constructor(configs, name, mode2) {
     super(configs, name, mode2);
+    this.logStreams = {};
+    this.sidecars = {};
+    this.clients = /* @__PURE__ */ new Set();
+    this.runningProcesses = /* @__PURE__ */ new Map();
+    this.allProcesses = /* @__PURE__ */ new Map();
+    this.processLogs = /* @__PURE__ */ new Map();
     this.getRunnables = (tests, testName, payload = {
       nodeEntryPoints: {},
       nodeEntryPointSidecars: {},
@@ -730,11 +885,11 @@ var PM_Main = class extends PM_WithEslintAndTsc {
       console.log(ansiC2.green(ansiC2.inverse(`pure < ${src}`)));
       this.bddTestIsRunning(src);
       const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/pure`;
-      if (!fs3.existsSync(reportDest)) {
-        fs3.mkdirSync(reportDest, { recursive: true });
+      if (!fs4.existsSync(reportDest)) {
+        fs4.mkdirSync(reportDest, { recursive: true });
       }
       const destFolder = dest.replace(".mjs", "");
-      let argz = "";
+      let argz2 = "";
       const testConfig = this.configs.tests.find((t) => {
         return t[0] === src;
       });
@@ -745,7 +900,7 @@ var PM_Main = class extends PM_WithEslintAndTsc {
       const testConfigResource = testConfig[2];
       const portsToUse = [];
       if (testConfigResource.ports === 0) {
-        argz = JSON.stringify({
+        argz2 = JSON.stringify({
           scheduled: true,
           name: src,
           ports: portsToUse,
@@ -761,7 +916,7 @@ var PM_Main = class extends PM_WithEslintAndTsc {
             portsToUse.push(openPorts[i][0]);
             this.ports[openPorts[i][0]] = src;
           }
-          argz = JSON.stringify({
+          argz2 = JSON.stringify({
             scheduled: true,
             name: src,
             ports: portsToUse,
@@ -770,22 +925,24 @@ var PM_Main = class extends PM_WithEslintAndTsc {
           });
         } else {
           this.queue.push(src);
-          return;
+          return [Math.random(), argz2];
         }
       } else {
         console.error("negative port makes no sense", src);
         process.exit(-1);
       }
       const builtfile = dest;
+      const logs = createLogStreams(reportDest, "pure");
       try {
         await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+          const originalConsole = { ...console };
           return module.default.then((defaultModule) => {
-            defaultModule.receiveTestResourceConfig(argz).then(async (results) => {
+            defaultModule.receiveTestResourceConfig(argz2).then(async (results) => {
               statusMessagePretty(results.fails, src, "pure");
               this.bddTestIsNowDone(src, results.fails);
             }).catch((e1) => {
               console.log(
-                ansiC2.red(`launchPure - ${src} errored with: ${e1}`)
+                ansiC2.red(`launchPure - ${src} errored with: ${e1.stack}`)
               );
               this.bddTestIsNowDone(src, -1);
               statusMessagePretty(-1, src, "pure");
@@ -793,27 +950,29 @@ var PM_Main = class 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");
           }).finally((x) => {
           });
         });
       } catch (e3) {
+        logs.writeExitCode(-1, e3);
         console.log(
           ansiC2.red(
             ansiC2.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++) {
         if (portsToUse[i]) {
@@ -825,8 +984,8 @@ var PM_Main = class extends PM_WithEslintAndTsc {
       console.log(ansiC2.green(ansiC2.inverse(`node < ${src}`)));
       this.bddTestIsRunning(src);
       const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/node`;
-      if (!fs3.existsSync(reportDest)) {
-        fs3.mkdirSync(reportDest, { recursive: true });
+      if (!fs4.existsSync(reportDest)) {
+        fs4.mkdirSync(reportDest, { recursive: true });
       }
       let testResources = "";
       const testConfig = this.configs.tests.find((t) => {
@@ -872,7 +1031,7 @@ var PM_Main = class extends PM_WithEslintAndTsc {
             )
           );
           this.queue.push(src);
-          return;
+          return [Math.random(), argz];
         }
       } else {
         console.error("negative port makes no sense", src);
@@ -931,41 +1090,46 @@ var PM_Main = class extends PM_WithEslintAndTsc {
           }
         });
       });
-      const oStream = fs3.createWriteStream(`${reportDest}/logs.txt`);
-      const errFile = `${reportDest}/logs.txt`;
-      if (fs3.existsSync(errFile)) {
-        fs3.rmSync(errFile);
-      }
+      const logs = createLogStreams(reportDest, "node");
       server.listen(ipcfile, () => {
-        child.stderr?.on("data", (data) => {
-          oStream.write(`stderr > ${data}`);
-        });
         child.stdout?.on("data", (data) => {
-          oStream.write(`stdout > ${data}`);
+          logs.stdout?.write(data);
+        });
+        child.stderr?.on("data", (data) => {
+          logs.stderr?.write(data);
         });
         child.on("error", (err) => {
         });
         child.on("close", (code) => {
+          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 (!files2[src]) {
             files2[src] = /* @__PURE__ */ new Set();
           }
-          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;
         });
@@ -983,11 +1147,10 @@ var PM_Main = class extends PM_WithEslintAndTsc {
           console.log(
             ansiC2.red(
               ansiC2.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");
         });
@@ -998,9 +1161,7 @@ var PM_Main = class extends PM_WithEslintAndTsc {
       const dest = src.split(".").slice(0, -1).join(".");
       const destFolder = dest.replace(".mjs", "");
       console.log(ansiC2.green(ansiC2.inverse(`launchWebSideCar ${src}`)));
-      const fileStreams2 = [];
-      const doneFileStream2 = [];
-      const oStream = fs3.createWriteStream(`${destFolder}/logs.txt`);
+      const logs = createLogStreams(dest, "web");
       return new Promise((res, rej) => {
         this.browser.newPage().then(async (page) => {
           this.mapping().forEach(async ([command, func]) => {
@@ -1014,34 +1175,44 @@ var PM_Main = class extends PM_WithEslintAndTsc {
             Promise.all(screenshots2[src] || []).then(() => {
               delete screenshots2[src];
               page.close();
-              oStream.close();
             });
           };
           page.on("pageerror", (err) => {
             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) => {
-            oStream.write(log.text());
-            oStream.write(JSON.stringify(log.location()));
-            oStream.write(JSON.stringify(log.stackTrace()));
-            oStream.write("\n");
+            const msg = `${log.text()}
+${JSON.stringify(
+              log.location()
+            )}
+${JSON.stringify(log.stackTrace())}
+`;
+            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`}`, {});
           const webArgz = JSON.stringify({
@@ -1087,13 +1258,14 @@ var PM_Main = class extends PM_WithEslintAndTsc {
       console.log(ansiC2.green(ansiC2.inverse(`launchNodeSideCar ${sidecar[0]}`)));
       const destFolder = dest.replace(".ts", "");
       const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/node`;
-      const argz = {
+      const argz2 = {
         name: sidecar[0],
         ports: [],
         fs: destFolder,
         browserWSEndpoint: this.browser.wsEndpoint()
       };
       const testReq = sidecar[2];
+      const logs = createLogStreams(dest, "node");
       const portsToUse = [];
       if (testReq.ports === 0) {
       } else if (testReq.ports > 0) {
@@ -1102,10 +1274,10 @@ var PM_Main = class 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]));
             this.ports[openPorts[i][0]] = src;
           }
-          argz.ports = portsToUse;
+          argz2.ports = portsToUse;
           const builtfile = destFolder + ".mjs";
           let haltReturns = false;
           let buffer = new Buffer("");
@@ -1142,22 +1314,13 @@ var PM_Main = class extends PM_WithEslintAndTsc {
               });
             });
           });
-          const oStream = fs3.createWriteStream(`${reportDest}/logs.txt`);
-          const child = spawn("node", [builtfile, JSON.stringify(argz)], {
+          const child = spawn("node", [builtfile, JSON.stringify(argz2)], {
             stdio: ["pipe", "pipe", "pipe", "ipc"]
             // silent: true
           });
           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;
             });
@@ -1170,24 +1333,24 @@ var PM_Main = class extends PM_WithEslintAndTsc {
               }
             });
             child.on("error", (e) => {
-              if (fs3.existsSync(p)) {
-                fs3.rmSync(p);
+              if (fs4.existsSync(p)) {
+                fs4.rmSync(p);
               }
               haltReturns = true;
               console.log(
                 ansiC2.red(
                   ansiC2.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");
             });
           });
           child.send({ path: p });
           const r = Math.random();
           this.nodeSidecars[r] = child;
-          return [r, argz];
+          return [r, argz2];
         } else {
           console.log(
             ansiC2.red(
@@ -1195,7 +1358,7 @@ var PM_Main = class extends PM_WithEslintAndTsc {
             )
           );
           this.queue.push(sidecar[0]);
-          return [Math.random(), argz];
+          return [Math.random(), argz2];
         }
       } else {
         console.error("negative port makes no sense", sidecar[0]);
@@ -1213,13 +1376,13 @@ var PM_Main = class extends PM_WithEslintAndTsc {
       const dest = process.cwd() + `/testeranto/bundles/pure/${this.name}/${sidecar[0]}`;
       const builtfile = dest.split(".").slice(0, -1).concat("mjs").join(".");
       const destFolder = dest.replace(".mjs", "");
-      let argz;
+      let argz2;
       const z = sidecar[2];
       const testConfigResource = sidecar[2];
       const src = sidecar[0];
       const portsToUse = [];
       if (testConfigResource.ports === 0) {
-        argz = {
+        argz2 = {
           // scheduled: true,
           name: src,
           ports: portsToUse,
@@ -1232,10 +1395,10 @@ var PM_Main = class 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;
           }
-          argz = {
+          argz2 = {
             // scheduled: true,
             name: src,
             // ports: [3333],
@@ -1245,24 +1408,25 @@ var PM_Main = class extends PM_WithEslintAndTsc {
           };
         } else {
           this.queue.push(src);
-          return;
         }
       } else {
         console.error("negative port makes no sense", src);
         process.exit(-1);
       }
       await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+        if (!this.pureSidecars)
+          this.pureSidecars = {};
         this.pureSidecars[r] = module.default;
-        this.pureSidecars[r].start(argz);
+        this.pureSidecars[r].start(argz2);
       });
-      return [r, argz];
+      return [r, argz2];
     };
     this.launchWeb = async (src, dest) => {
       console.log(ansiC2.green(ansiC2.inverse(`web < ${src}`)));
       this.bddTestIsRunning(src);
       const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/web`;
-      if (!fs3.existsSync(reportDest)) {
-        fs3.mkdirSync(reportDest, { recursive: true });
+      if (!fs4.existsSync(reportDest)) {
+        fs4.mkdirSync(reportDest, { recursive: true });
       }
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
@@ -1272,9 +1436,33 @@ var PM_Main = class extends PM_WithEslintAndTsc {
         browserWSEndpoint: this.browser.wsEndpoint()
       });
       const d = `${dest}?cacheBust=${Date.now()}`;
-      const ofile = `${reportDest}/logs.txt`;
-      const oStream = fs3.createWriteStream(ofile);
+      const logs = createLogStreams(reportDest, "web");
       this.browser.newPage().then((page) => {
+        page.on("console", (log) => {
+          const msg = `${log.text()}
+`;
+          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);
+          logs.closeAll();
+          logs.closeAll();
+        });
         this.mapping().forEach(async ([command, func]) => {
           if (command === "page") {
             page.exposeFunction(command, (x) => {
@@ -1298,46 +1486,19 @@ var PM_Main = class extends PM_WithEslintAndTsc {
           Promise.all(screenshots2[src] || []).then(() => {
             delete screenshots2[src];
             page.close();
-            oStream.close();
           });
           return;
         };
         page.on("pageerror", (err) => {
+          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) => {
-          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");
-          }
-        });
         await page.goto(`file://${`${destFolder}.html`}`, {});
         await page.evaluate(
           `
@@ -1357,7 +1518,7 @@ import('${d}').then(async (x) => {
           console.log(
             ansiC2.red(
               ansiC2.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`
               )
             )
           );
@@ -1376,9 +1537,19 @@ import('${d}').then(async (x) => {
         "strings",
         srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
       );
-      const testReport = JSON.parse(
-        fs3.readFileSync(`${reportDest}/tests.json`).toString()
-      );
+      const testReportPath = `${reportDest}/tests.json`;
+      if (!fs4.existsSync(testReportPath)) {
+        console.error(`tests.json not found at: ${testReportPath}`);
+        return;
+      }
+      const testReport = JSON.parse(fs4.readFileSync(testReportPath, "utf8"));
+      if (testReport.tests) {
+        testReport.tests.forEach((test) => {
+          test.fullPath = path4.resolve(process.cwd(), srcTest);
+        });
+      }
+      testReport.fullPath = path4.resolve(process.cwd(), srcTest);
+      fs4.writeFileSync(testReportPath, JSON.stringify(testReport, null, 2));
       testReport.features.reduce(async (mm, featureStringKey) => {
         const accum = await mm;
         const isUrl = isValidUrl(featureStringKey);
@@ -1397,14 +1568,14 @@ import('${d}').then(async (x) => {
             accum.files.push(newPath);
           }
         } else {
-          await fs3.promises.mkdir(path4.dirname(featureDestination), {
+          await fs4.promises.mkdir(path4.dirname(featureDestination), {
             recursive: true
           });
           accum.strings.push(featureStringKey);
         }
         return accum;
       }, Promise.resolve({ files: [], strings: [] })).then(({ files: files3, strings }) => {
-        fs3.writeFileSync(
+        fs4.writeFileSync(
           `testeranto/reports/${this.name}/${srcTest.split(".").slice(0, -1).join(".")}/${platform}/featurePrompt.txt`,
           files3.map((f) => {
             return `/read ${f}`;
@@ -1460,10 +1631,16 @@ import('${d}').then(async (x) => {
       });
       this.writeBigBoard();
       if (!inflight) {
-        this.browser.disconnect().then(() => {
-          console.log(ansiC2.inverse(`${this.name} has been tested. Goodbye.`));
-          process.exit();
-        });
+        if (this.browser) {
+          if (this.browser) {
+            this.browser.disconnect().then(() => {
+              console.log(
+                ansiC2.inverse(`${this.name} has been tested. Goodbye.`)
+              );
+              process.exit();
+            });
+          }
+        }
       }
     };
     this.launchers = {};
@@ -1475,6 +1652,185 @@ import('${d}').then(async (x) => {
     this.configs.ports.forEach((element) => {
       this.ports[element] = "";
     });
+    this.httpServer = http.createServer(this.requestHandler.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 {
+          const message = JSON.parse(data.toString());
+          if (message.type === "executeCommand") {
+            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: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              this.processLogs.set(processId, []);
+              this.broadcast({
+                type: "processStarted",
+                processId,
+                command: message.command,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                logs: []
+              });
+              child.stdout?.on("data", (data2) => {
+                const logData = data2.toString();
+                const logs = this.processLogs.get(processId) || [];
+                logs.push(logData);
+                this.processLogs.set(processId, logs);
+                this.broadcast({
+                  type: "processStdout",
+                  processId,
+                  data: logData,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              });
+              child.stderr?.on("data", (data2) => {
+                const logData = data2.toString();
+                const logs = this.processLogs.get(processId) || [];
+                logs.push(logData);
+                this.processLogs.set(processId, logs);
+                this.broadcast({
+                  type: "processStderr",
+                  processId,
+                  data: logData,
+                  timestamp: (/* @__PURE__ */ 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.broadcast({
+                  type: "processError",
+                  processId,
+                  error: error.message,
+                  timestamp: (/* @__PURE__ */ 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",
+                    exitCode: code
+                  });
+                }
+                this.broadcast({
+                  type: "processExited",
+                  processId,
+                  exitCode: code,
+                  timestamp: (/* @__PURE__ */ 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,
+                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,
+                  logs: this.processLogs.get(processId) || []
+                })
+              );
+            }
+          } else if (message.type === "stdin") {
+            const processId = message.processId;
+            const data2 = message.data;
+            console.log("Received stdin for process", processId, ":", data2);
+            const childProcess = this.runningProcesses.get(processId);
+            if (childProcess && childProcess.stdin) {
+              console.log("Writing to process stdin");
+              childProcess.stdin.write(data2);
+            } 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);
+            if (childProcess) {
+              console.log("Killing process");
+              childProcess.kill("SIGTERM");
+            } 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);
+      });
+    });
+    const httpPort = Number(process.env.HTTP_PORT) || 3e3;
+    this.httpServer.listen(httpPort, () => {
+      console.log(`HTTP server running on http://localhost:${httpPort}`);
+    });
   }
   async stopSideCar(uid) {
     console.log(ansiC2.green(ansiC2.inverse(`stopSideCar ${uid}`)));
@@ -1552,8 +1908,8 @@ import('${d}').then(async (x) => {
     this.mapping().forEach(async ([command, func]) => {
       globalThis[command] = func;
     });
-    if (!fs3.existsSync(`testeranto/reports/${this.name}`)) {
-      fs3.mkdirSync(`testeranto/reports/${this.name}`);
+    if (!fs4.existsSync(`testeranto/reports/${this.name}`)) {
+      fs4.mkdirSync(`testeranto/reports/${this.name}`);
     }
     const executablePath = "/opt/homebrew/bin/chromium";
     try {
@@ -1562,16 +1918,18 @@ import('${d}').then(async (x) => {
         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",
@@ -1581,6 +1939,7 @@ import('${d}').then(async (x) => {
           "--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",
@@ -1630,7 +1989,7 @@ import('${d}').then(async (x) => {
       ]
     ].forEach(
       async ([eps, launcher, runtime, watcher]) => {
-        const metafile = `./testeranto/bundles/${runtime}/${this.name}/metafile.json`;
+        const metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
         await pollForFile(metafile);
         Object.entries(eps).forEach(
           async ([inputFile, outputFile]) => {
@@ -1700,13 +2059,22 @@ import('${d}').then(async (x) => {
     this.nodeMetafileWatcher.close();
     this.webMetafileWatcher.close();
     this.importMetafileWatcher.close();
+    Object.values(this.logStreams || {}).forEach((logs) => logs.closeAll());
+    this.wss.close(() => {
+      console.log("WebSocket server closed");
+    });
+    this.clients.forEach((client) => {
+      client.terminate();
+    });
+    this.clients.clear();
+    this.httpServer.close(() => {
+      console.log("HTTP server closed");
+    });
     this.checkForShutdown();
   }
   async metafileOutputs(platform) {
     const metafile = JSON.parse(
-      fs3.readFileSync(
-        `./testeranto/bundles/${platform}/${this.name}/metafile.json`
-      ).toString()
+      fs4.readFileSync(`./testeranto/metafiles/${platform}/${this.name}.json`).toString()
     ).metafile;
     if (!metafile)
       return;
@@ -1717,7 +2085,7 @@ import('${d}').then(async (x) => {
         return false;
       }
       const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
-        if (!fs3.existsSync(i))
+        if (!fs4.existsSync(i))
           return false;
         if (i.startsWith("node_modules"))
           return false;
@@ -1726,8 +2094,8 @@ import('${d}').then(async (x) => {
         return true;
       });
       const f = `${k.split(".").slice(0, -1).join(".")}/`;
-      if (!fs3.existsSync(f)) {
-        fs3.mkdirSync(f);
+      if (!fs4.existsSync(f)) {
+        fs4.mkdirSync(f);
       }
       const entrypoint = outputs[k].entryPoint;
       if (entrypoint) {
@@ -1746,6 +2114,121 @@ import('${d}').then(async (x) => {
       }
     });
   }
+  requestHandler(req, res) {
+    const parsedUrl = url.parse(req.url || "/");
+    let pathname = parsedUrl.pathname || "/";
+    if (pathname === "/") {
+      pathname = "/index.html";
+    }
+    let filePath = pathname.substring(1);
+    if (filePath.startsWith("reports/")) {
+      filePath = `testeranto/${filePath}`;
+    } else if (filePath.startsWith("metafiles/")) {
+      filePath = `testeranto/${filePath}`;
+    } else if (filePath === "projects.json") {
+      filePath = `testeranto/${filePath}`;
+    } else {
+      const possiblePaths = [
+        `dist/${filePath}`,
+        `testeranto/dist/${filePath}`,
+        `../dist/${filePath}`,
+        `./${filePath}`
+      ];
+      let foundPath = null;
+      for (const possiblePath of possiblePaths) {
+        if (fs4.existsSync(possiblePath)) {
+          foundPath = possiblePath;
+          break;
+        }
+      }
+      if (foundPath) {
+        filePath = foundPath;
+      } else {
+        const indexPath = this.findIndexHtml();
+        if (indexPath) {
+          fs4.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;
+        }
+      }
+    }
+    fs4.exists(filePath, (exists) => {
+      if (!exists) {
+        if (!pathname.includes(".") && pathname !== "/") {
+          const indexPath = this.findIndexHtml();
+          if (indexPath) {
+            fs4.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(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;
+      }
+      fs4.readFile(filePath, (err, data) => {
+        if (err) {
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("500 Internal Server Error");
+          return;
+        }
+        const mimeType = mime.lookup(filePath) || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": mimeType });
+        res.end(data);
+      });
+    });
+  }
+  findIndexHtml() {
+    const possiblePaths = [
+      "dist/index.html",
+      "testeranto/dist/index.html",
+      "../dist/index.html",
+      "./index.html"
+    ];
+    for (const path5 of possiblePaths) {
+      if (fs4.existsSync(path5)) {
+        return path5;
+      }
+    }
+    return null;
+  }
+  broadcast(message) {
+    const data = typeof message === "string" ? message : JSON.stringify(message);
+    this.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        client.send(data);
+      }
+    });
+  }
   checkQueue() {
     const x = this.queue.pop();
     if (!x) {