testeranto 0.100.0 → 0.110.0

package/dist/prebuild/{cli2.mjs → run.mjs}

@@ -1,13 +1,64 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
 
-// src/cli2.ts
+// src/run.ts
+import ansiC2 from "ansi-colors";
 import { watch } from "fs";
+import path3 from "path";
+import crypto from "node:crypto";
+import fs2 from "fs";
+import tsc from "tsc-prog";
+import { ESLint } from "eslint";
+import ts from "typescript";
+import readline from "readline";
 
 // src/PM/main.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 import puppeteer from "puppeteer-core";
-import crypto from "crypto";
+import ansiC from "ansi-colors";
+
+// src/utils.ts
+import path from "path";
+var tscPather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `type_errors.txt`
+  );
+};
+var tscExitCodePather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `type_errors.txt`
+  );
+};
+var lintPather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `lint_errors.json`
+  );
+};
+var lintExitCodePather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `lint_errors.txt`
+  );
+};
+var bddExitCodePather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `bdd_errors.txt`
+  );
+};
 
 // src/PM/index.ts
 var PM = class {
@@ -19,49 +70,80 @@ var fPaths = [];
 var files = {};
 var recorders = {};
 var screenshots = {};
-var red = "\x1B[31m";
-var green = "\x1B[32m";
-var reset = "\x1B[0m";
 var statusMessagePretty = (failures, test) => {
   if (failures === 0) {
-    console.log(green + `${test} completed successfully` + reset);
+    console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
   } else {
-    console.log(red + `${test} failed ${failures} times` + reset);
+    console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
   }
 };
+async function writeFileAndCreateDir(filePath, data) {
+  const dirPath = path2.dirname(filePath);
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+    await fs.appendFileSync(filePath, data);
+  } catch (error) {
+    console.error(`Error writing file: ${error}`);
+  }
+}
+function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
 var PM_Main = class extends PM {
   constructor(configs) {
     super();
     this.shutdownMode = false;
+    this.bigBoard = {};
     this.checkForShutdown = () => {
-      const anyRunning = Object.values(this.registry).filter((x) => x === false).length > 0;
+      const anyRunning = Object.values(this.bigBoard).filter((x) => x.status === "running").length > 0;
       if (anyRunning) {
       } else {
         this.browser.disconnect().then(() => {
-          console.log("Goodbye");
+          const final = {
+            timestamp: Date.now(),
+            tests: this.configs.tests.reduce((mm, t) => {
+              const bddErrors = fs.readFileSync(bddExitCodePather(t[0], t[1])).toString();
+              const lintErrors = fs.readFileSync(lintExitCodePather(t[0], t[1])).toString();
+              const typeErrors = fs.readFileSync(tscExitCodePather(t[0], t[1])).toString();
+              mm[t[0]] = {
+                bddErrors,
+                lintErrors,
+                typeErrors
+              };
+              return mm;
+            }, {})
+          };
+          const s = JSON.stringify(final, null, 2);
+          fs.writeFileSync("docs/summary.json", s);
+          console.log(ansiC.inverse("Goodbye"));
           process.exit();
         });
       }
     };
-    this.register = (src) => {
-      this.registry[src] = false;
+    this.testIsNowRunning = (src) => {
+      this.bigBoard[src].status = "running";
     };
-    this.deregister = (src) => {
-      this.registry[src] = true;
+    this.testIsNowDone = (src) => {
+      this.bigBoard[src].status = "waiting";
       if (this.shutdownMode) {
         this.checkForShutdown();
       }
     };
     this.launchNode = async (src, dest) => {
-      console.log("! node", src);
-      this.register(src);
+      console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+      this.testIsNowRunning(src);
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
       const testConfig = this.configs.tests.find((t) => {
         return t[0] === src;
       });
       if (!testConfig) {
-        console.error("missing test config");
+        console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
         process.exit(-1);
       }
       const testConfigResource = testConfig[2];
@@ -106,11 +188,12 @@ var PM_Main = class extends PM {
           defaultModule.receiveTestResourceConfig(argz).then(async ({ features, failed }) => {
             this.receiveFeatures(features, destFolder, src);
             statusMessagePretty(failed, src);
+            this.receiveExitCode(src, failed);
           }).catch((e) => {
-            console.log(`${src} errored with`, e);
+            console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
           }).finally(() => {
             webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.deregister(src);
+            this.testIsNowDone(src);
           });
         });
       });
@@ -122,7 +205,7 @@ var PM_Main = class extends PM {
     };
     this.launchWebSideCar = async (src, dest, testConfig) => {
       const d = dest + ".mjs";
-      console.log("launchWebSideCar", src, dest, d);
+      console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
       const destFolder = dest.replace(".mjs", "");
       const fileStreams2 = [];
       const doneFileStream2 = [];
@@ -132,7 +215,7 @@ var PM_Main = class extends PM {
             "custom-screenshot",
             async (ssOpts, testName) => {
               const p = ssOpts.path;
-              const dir = path.dirname(p);
+              const dir = path2.dirname(p);
               fs.mkdirSync(dir, {
                 recursive: true
               });
@@ -152,7 +235,7 @@ var PM_Main = class extends PM {
           page.exposeFunction(
             "writeFileSync",
             (fp, contents, testName) => {
-              const dir = path.dirname(fp);
+              const dir = path2.dirname(fp);
               fs.mkdirSync(dir, {
                 recursive: true
               });
@@ -216,7 +299,7 @@ var PM_Main = class extends PM {
     };
     this.launchNodeSideCar = async (src, dest, testConfig) => {
       const d = dest + ".mjs";
-      console.log("launchNodeSideCar", src, dest, d);
+      console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
       const testConfigResource = testConfig[2];
@@ -268,8 +351,8 @@ var PM_Main = class extends PM {
       }
     };
     this.launchWeb = (t, dest) => {
-      console.log("! web", t);
-      this.register(t);
+      console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
+      this.testIsNowRunning(t);
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
         name: dest,
@@ -279,9 +362,9 @@ var PM_Main = class extends PM {
       });
       const d = `${dest}?cacheBust=${Date.now()}`;
       const evaluation = `
-    console.log("importing ${d}");
+
     import('${d}').then(async (x) => {
-      console.log("imported", (await x.default));
+
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -297,7 +380,7 @@ var PM_Main = class extends PM {
           "screencast",
           async (ssOpts, testName) => {
             const p = ssOpts.path;
-            const dir = path.dirname(p);
+            const dir = path2.dirname(p);
             fs.mkdirSync(dir, {
               recursive: true
             });
@@ -321,7 +404,7 @@ var PM_Main = class extends PM {
           "customScreenShot",
           async (ssOpts, testName) => {
             const p = ssOpts.path;
-            const dir = path.dirname(p);
+            const dir = path2.dirname(p);
             fs.mkdirSync(dir, {
               recursive: true
             });
@@ -440,7 +523,7 @@ var PM_Main = class extends PM {
           Promise.all(screenshots[t] || []).then(() => {
             delete screenshots[t];
             page.close();
-            this.deregister(t);
+            this.testIsNowDone(t);
             stderrStream.close();
             stdoutStream.close();
           });
@@ -458,6 +541,7 @@ var PM_Main = class extends PM {
           }
           console.debug(`Error from message ${t}: [${err.message}] `);
           stderrStream.write(err.message);
+          close();
         });
         page.on("console", (log) => {
           stdoutStream.write(log.text());
@@ -468,8 +552,9 @@ var PM_Main = class extends PM {
         await page.evaluate(evaluation).then(async ({ failed, features }) => {
           this.receiveFeatures(features, destFolder, t);
           statusMessagePretty(failed, t);
+          this.receiveExitCode(t, failed);
         }).catch((e) => {
-          console.log(`${t} errored with`, e);
+          console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
         }).finally(() => {
           close();
         });
@@ -477,7 +562,7 @@ var PM_Main = class extends PM {
       });
     };
     this.receiveFeatures = (features, destFolder, srcTest) => {
-      const featureDestination = path.resolve(
+      const featureDestination = path2.resolve(
         process.cwd(),
         "docs",
         "features",
@@ -490,22 +575,17 @@ var PM_Main = class extends PM {
         if (isUrl) {
           const u = new URL(featureStringKey);
           if (u.protocol === "file:") {
-            const newPath = `${process.cwd()}/docs/features/internal/${path.relative(
+            const newPath = `${process.cwd()}/docs/features/internal/${path2.relative(
               process.cwd(),
               u.pathname
             )}`;
-            await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
+            await fs.promises.mkdir(path2.dirname(newPath), { recursive: true });
             try {
               await fs.unlinkSync(newPath);
             } catch (error) {
               if (error.code !== "ENOENT") {
               }
             }
-            fs.symlink(u.pathname, newPath, (err) => {
-              if (err) {
-              } else {
-              }
-            });
             accum.files.push(newPath);
           } else if (u.protocol === "http:" || u.protocol === "https:") {
             const newPath = `${process.cwd()}/docs/features/external${u.hostname}${u.pathname}`;
@@ -514,7 +594,7 @@ var PM_Main = class extends PM {
             accum.files.push(newPath);
           }
         } else {
-          await fs.promises.mkdir(path.dirname(featureDestination), {
+          await fs.promises.mkdir(path2.dirname(featureDestination), {
             recursive: true
           });
           accum.strings.push(featureStringKey);
@@ -528,32 +608,49 @@ var PM_Main = class extends PM {
           }).join("\n")
         );
       });
+      this.writeBigBoard();
+    };
+    this.receiveExitCode = (srcTest, failures) => {
+      this.bigBoard[srcTest].runTimeError = failures;
+      this.writeBigBoard();
+    };
+    this.writeBigBoard = () => {
+      fs.writeFileSync(
+        "./docs/bigBoard.json",
+        JSON.stringify(this.bigBoard, null, 2)
+      );
     };
     this.server = {};
     this.configs = configs;
     this.ports = {};
-    this.registry = {};
+    this.configs.tests.forEach(([t]) => {
+      this.bigBoard[t] = {
+        status: "?"
+      };
+    });
     this.configs.ports.forEach((element) => {
       this.ports[element] = "true";
     });
     globalThis["waitForSelector"] = async (pageKey, sel) => {
-      console.log("waitForSelector", pageKey, sel);
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
       await page?.waitForSelector(sel);
     };
-    globalThis["screencastStop"] = async (path3) => {
-      return recorders[path3].stop();
+    globalThis["screencastStop"] = async (path4) => {
+      return recorders[path4].stop();
     };
     globalThis["closePage"] = async (pageKey) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
       return page.close();
     };
     globalThis["goto"] = async (pageKey, url) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p) => p.mainFrame()._id === pageKey
       );
       await page?.goto(url);
@@ -574,8 +671,7 @@ var PM_Main = class extends PM {
       return false;
     };
     globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      const dir = path.dirname(filepath);
-      fs.mkdirSync(dir, {
+      fs.mkdirSync(path2.dirname(filepath), {
         recursive: true
       });
       if (!files[testName]) {
@@ -604,10 +700,11 @@ var PM_Main = class extends PM {
     };
     globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p2) => p2.mainFrame()._id === pageKey
       );
       const p = opts.path;
-      const dir = path.dirname(p);
+      const dir = path2.dirname(p);
       fs.mkdirSync(dir, {
         recursive: true
       });
@@ -628,10 +725,11 @@ var PM_Main = class extends PM {
     };
     globalThis["screencast"] = async (opts, pageKey) => {
       const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
         (p2) => p2.mainFrame()._id === pageKey
       );
       const p = opts.path;
-      const dir = path.dirname(p);
+      const dir = path2.dirname(p);
       fs.mkdirSync(dir, {
         recursive: true
       });
@@ -692,7 +790,7 @@ var PM_Main = class extends PM {
       callback(
         new Promise((res, rej) => {
           tLog("testArtiFactory =>", fPath);
-          const cleanPath = path.resolve(fPath);
+          const cleanPath = path2.resolve(fPath);
           fPaths.push(cleanPath.replace(process.cwd(), ``));
           const targetDir = cleanPath.split("/").slice(0, -1).join("/");
           fs.mkdir(targetDir, { recursive: true }, async (error) => {
@@ -700,7 +798,7 @@ var PM_Main = class extends PM {
               console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
             }
             fs.writeFileSync(
-              path.resolve(
+              path2.resolve(
                 targetDir.split("/").slice(0, -1).join("/"),
                 "manifest"
               ),
@@ -763,39 +861,32 @@ var PM_Main = class extends PM {
   async startPuppeteer(options, destfolder) {
     this.browser = await puppeteer.launch(options);
   }
-  ////////////////////////////////////////////////////////////////////////////////
+  // goodbye = () => {
+  //   this.browser.disconnect().then(() => {
+  //     console.log("Goodbye");
+  //     process.exit();
+  //   });
+  // };
   shutDown() {
-    console.log("shutting down...");
     this.shutdownMode = true;
     this.checkForShutdown();
   }
 };
-async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path.dirname(filePath);
-  try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.appendFileSync(filePath, data);
-  } catch (error) {
-    console.error(`Error writing file: ${error}`);
-  }
-}
-function isValidUrl(string) {
-  try {
-    new URL(string);
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
 
-// src/cli2.ts
-import path2 from "path";
-import crypto2 from "node:crypto";
-import fs2 from "fs";
-var fileHashes = {};
+// src/run.ts
+console.log(ansiC2.inverse("Press 'x' to shutdown forcefully."));
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+  process.stdin.setRawMode(true);
+process.stdin.on("keypress", (str, key) => {
+  if (key.name === "x") {
+    console.log(ansiC2.inverse("Shutting down forcefully..."));
+    process.exit(-1);
+  }
+});
 async function fileHash(filePath, algorithm = "md5") {
   return new Promise((resolve, reject) => {
-    const hash = crypto2.createHash(algorithm);
+    const hash = crypto.createHash(algorithm);
     const fileStream = fs2.createReadStream(filePath);
     fileStream.on("data", (data) => {
       hash.update(data);
@@ -809,17 +900,26 @@ async function fileHash(filePath, algorithm = "md5") {
     });
   });
 }
+async function filesHash(files2, algorithm = "md5") {
+  return new Promise((resolve, reject) => {
+    resolve(
+      files2.reduce(async (mm, f) => {
+        return await mm + await fileHash(f);
+      }, Promise.resolve(""))
+    );
+  });
+}
 var getRunnables = (tests, payload = {
   nodeEntryPoints: {},
   webEntryPoints: {}
 }) => {
   return tests.reduce((pt, cv, cndx, cry) => {
     if (cv[1] === "node") {
-      pt.nodeEntryPoints[cv[0]] = path2.resolve(
+      pt.nodeEntryPoints[cv[0]] = path3.resolve(
         `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
       );
     } else if (cv[1] === "web") {
-      pt.webEntryPoints[cv[0]] = path2.resolve(
+      pt.webEntryPoints[cv[0]] = path3.resolve(
         `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
       );
     }
@@ -829,13 +929,187 @@ var getRunnables = (tests, payload = {
     return pt;
   }, payload);
 };
+var changes = {};
+var tscCheck = async ({
+  entrypoint,
+  addableFiles,
+  platform
+}) => {
+  console.log(ansiC2.green(ansiC2.inverse(`tsc < ${entrypoint}`)));
+  const program = tsc.createProgramFromConfig({
+    basePath: process.cwd(),
+    // always required, used for relative paths
+    configFilePath: "tsconfig.json",
+    // config to inherit from (optional)
+    compilerOptions: {
+      rootDir: "src",
+      outDir: tscPather(entrypoint, platform),
+      // declaration: true,
+      // skipLibCheck: true,
+      noEmit: true
+    },
+    include: addableFiles
+    //["src/**/*"],
+    // exclude: ["**/*.test.ts", "**/*.spec.ts"],
+  });
+  const tscPath = tscPather(entrypoint, platform);
+  let allDiagnostics = program.getSemanticDiagnostics();
+  const d = [];
+  allDiagnostics.forEach((diagnostic) => {
+    if (diagnostic.file) {
+      let { line, character } = ts.getLineAndCharacterOfPosition(
+        diagnostic.file,
+        diagnostic.start
+      );
+      let message = ts.flattenDiagnosticMessageText(
+        diagnostic.messageText,
+        "\n"
+      );
+      d.push(
+        `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`
+      );
+    } else {
+      d.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    }
+  });
+  fs2.writeFileSync(tscPath, d.join("\n"));
+  fs2.writeFileSync(
+    tscExitCodePather(entrypoint, platform),
+    d.length.toString()
+  );
+};
+var eslint = new ESLint();
+var formatter = await eslint.loadFormatter(
+  "./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs"
+);
+var eslintCheck = async (entrypoint, platform, addableFiles) => {
+  console.log(ansiC2.green(ansiC2.inverse(`eslint < ${entrypoint}`)));
+  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(
+    lintPather(entrypoint, platform),
+    await formatter.format(results)
+  );
+  fs2.writeFileSync(
+    lintExitCodePather(entrypoint, platform),
+    results.length.toString()
+  );
+};
+var makePrompt = async (entryPoint, addableFiles, platform) => {
+  const promptPath = path3.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `prompt.txt`
+  );
+  const testPaths = path3.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `tests.json`
+  );
+  const featuresPath = path3.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `featurePrompt.txt`
+  );
+  fs2.writeFileSync(
+    promptPath,
+    `
+${addableFiles.map((x) => {
+      return `/add ${x}`;
+    }).join("\n")}
+
+/read ${lintPather(entryPoint, platform)}
+/read ${tscPather(entryPoint, platform)}
+/read ${testPaths}
+
+/load ${featuresPath}
+
+/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files ${tscPather(
+      entryPoint,
+      platform
+    )}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPather(
+      entryPoint,
+      platform
+    )}"
+          `
+  );
+};
+var metafileOutputs = async (platform) => {
+  const metafile = JSON.parse(
+    fs2.readFileSync(`docs/${platform}/metafile.json`).toString()
+  ).metafile;
+  if (!metafile)
+    return;
+  const outputs = metafile.outputs;
+  Object.keys(outputs).forEach(async (k) => {
+    const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
+      if (!fs2.existsSync(i))
+        return false;
+      if (i.startsWith("node_modules"))
+        return false;
+      return true;
+    });
+    const f = `${k.split(".").slice(0, -1).join(".")}/`;
+    if (!fs2.existsSync(f)) {
+      fs2.mkdirSync(f);
+    }
+    const entrypoint = outputs[k].entryPoint;
+    if (entrypoint) {
+      const changeDigest = await filesHash(addableFiles);
+      if (changeDigest === changes[entrypoint]) {
+      } else {
+        changes[entrypoint] = changeDigest;
+        tscCheck({ platform, addableFiles, entrypoint });
+        eslintCheck(entrypoint, platform, addableFiles);
+        makePrompt(entrypoint, addableFiles, platform);
+      }
+    }
+  });
+};
 import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
   const rawConfig = module.default;
   const config = {
     ...rawConfig,
     buildDir: process.cwd() + "/" + rawConfig.outdir
   };
+  let mode = config.devMode ? "DEV" : "PROD";
+  const fileHashes = {};
   let pm = new PM_Main(config);
+  console.log(ansiC2.inverse(`Press 'q' to shutdown gracefully`));
+  process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+      console.log(
+        ansiC2.inverse("Testeranto-Run is shutting down gracefully...")
+      );
+      mode = "PROD";
+      nodeMetafileWatcher.close();
+      webMetafileWatcher.close();
+      pm.shutDown();
+    }
+  });
+  metafileOutputs("node");
+  const nodeMetafileWatcher = watch(
+    "docs/node/metafile.json",
+    async (e, filename) => {
+      console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename} (node)`)));
+      metafileOutputs("node");
+    }
+  );
+  metafileOutputs("web");
+  const webMetafileWatcher = watch(
+    "docs/web/metafile.json",
+    async (e, filename) => {
+      console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename} (web)`)));
+      metafileOutputs("web");
+    }
+  );
   await pm.startPuppeteer(
     {
       slowMo: 1,
@@ -885,14 +1159,13 @@ import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
   const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
   Object.entries(nodeEntryPoints).forEach(
     ([k, outputFile]) => {
-      console.log("watching and running", outputFile);
       pm.launchNode(k, outputFile);
       try {
         watch(outputFile, async (e, filename) => {
           const hash = await fileHash(outputFile);
           if (fileHashes[k] !== hash) {
             fileHashes[k] = hash;
-            console.log(`< ${e} ${filename} ${hash}`);
+            console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename}`)));
             pm.launchNode(k, outputFile);
           }
         });
@@ -903,13 +1176,12 @@ import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
   );
   Object.entries(webEntryPoints).forEach(
     ([k, outputFile]) => {
-      console.log("watching and running", outputFile);
       pm.launchWeb(k, outputFile);
       watch(outputFile, async (e, filename) => {
         const hash = await fileHash(outputFile);
-        console.log(`< ${e} ${filename} ${hash}`);
         if (fileHashes[k] !== hash) {
           fileHashes[k] = hash;
+          console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename}`)));
           pm.launchWeb(k, outputFile);
         }
       });