testeranto 0.189.0 → 0.198.0

package/dist/prebuild/run.mjs

@@ -13,6 +13,10 @@ 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";
@@ -163,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({});
       });
     });
@@ -269,8 +273,8 @@ var PM_Base = class {
           recursive: true
         });
       }
-      const f = fs.createWriteStream(filepath);
-      fileStreams3.push(f);
+      const f2 = fs.createWriteStream(filepath);
+      fileStreams3.push(f2);
       if (!files[testName]) {
         files[testName] = /* @__PURE__ */ new Set();
       }
@@ -393,27 +397,56 @@ import fs2 from "fs";
 import path3 from "path";
 
 // src/utils/logFiles.ts
-var NODE_LOG_FILES = ["stdout.log", "stderr.log", "exit.log"];
-var WEB_LOG_FILES = [
-  "info.log",
-  "debug.log",
-  "error.log",
-  "warn.log",
-  "exit.log"
-];
-var PURE_LOG_FILES = ["exit.log"];
-var getLogFilesForRuntime = (runtime) => {
-  switch (runtime) {
-    case "node":
-      return NODE_LOG_FILES;
-    case "web":
-      return WEB_LOG_FILES;
-    case "pure":
-      return PURE_LOG_FILES;
-    default:
-      throw new Error(`Unknown runtime: ${runtime}`);
-  }
+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) => {
@@ -429,10 +462,10 @@ var makePrompt = async (summary, name, entryPoint, addableFiles, runtime) => {
   if (!fs2.existsSync(testDir)) {
     fs2.mkdirSync(testDir, { recursive: true });
   }
-  const testPaths = path3.join(testDir, "tests.json");
-  const lintPath = path3.join(testDir, "lint_errors.txt");
-  const typePath = path3.join(testDir, "type_errors.txt");
-  const messagePath = path3.join(testDir, "message.txt");
+  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(
@@ -652,10 +685,13 @@ var PM_WithEslintAndTsc = class extends PM_Base {
       this.checkForShutdown();
     };
     this.writeBigBoard = () => {
-      fs3.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;
@@ -803,8 +839,8 @@ async function writeFileAndCreateDir(filePath, data) {
 var filesHash = async (files3, algorithm = "md5") => {
   return new Promise((resolve, reject) => {
     resolve(
-      files3.reduce(async (mm, f) => {
-        return await mm + await fileHash(f);
+      files3.reduce(async (mm, f2) => {
+        return await mm + await fileHash(f2);
       }, Promise.resolve(""))
     );
   });
@@ -831,6 +867,10 @@ var PM_Main = class extends PM_WithEslintAndTsc {
     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: {},
@@ -930,7 +970,7 @@ var PM_Main = class extends PM_WithEslintAndTsc {
           )
         );
         logs.exit.write(e3.stack);
-        logs.exit.write(-1);
+        logs.exit.write("-1");
         this.bddTestIsNowDone(src, -1);
         statusMessagePretty(-1, src, "pure");
       }
@@ -1497,9 +1537,19 @@ import('${d}').then(async (x) => {
         "strings",
         srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
       );
-      const testReport = JSON.parse(
-        fs4.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);
@@ -1527,8 +1577,8 @@ import('${d}').then(async (x) => {
       }, Promise.resolve({ files: [], strings: [] })).then(({ files: files3, strings }) => {
         fs4.writeFileSync(
           `testeranto/reports/${this.name}/${srcTest.split(".").slice(0, -1).join(".")}/${platform}/featurePrompt.txt`,
-          files3.map((f) => {
-            return `/read ${f}`;
+          files3.map((f2) => {
+            return `/read ${f2}`;
           }).join("\n")
         );
       });
@@ -1602,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}`)));
@@ -1760,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]) => {
@@ -1831,13 +2060,21 @@ import('${d}').then(async (x) => {
     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(
-      fs4.readFileSync(
-        `./testeranto/bundles/${platform}/${this.name}/metafile.json`
-      ).toString()
+      fs4.readFileSync(`./testeranto/metafiles/${platform}/${this.name}.json`).toString()
     ).metafile;
     if (!metafile)
       return;
@@ -1856,9 +2093,9 @@ import('${d}').then(async (x) => {
           return false;
         return true;
       });
-      const f = `${k.split(".").slice(0, -1).join(".")}/`;
-      if (!fs4.existsSync(f)) {
-        fs4.mkdirSync(f);
+      const f2 = `${k.split(".").slice(0, -1).join(".")}/`;
+      if (!fs4.existsSync(f2)) {
+        fs4.mkdirSync(f2);
       }
       const entrypoint = outputs[k].entryPoint;
       if (entrypoint) {
@@ -1877,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) {
@@ -1908,15 +2260,26 @@ if (mode !== "once" && mode !== "dev") {
   console.error("the 2nd argument should be 'dev' or 'once' ");
   process.exit(-1);
 }
-import(process.cwd() + "/testeranto.config.ts").then(async (module) => {
-  const bigConfig = module.default;
+var f = process.cwd() + "/testeranto.config.ts";
+console.log("config file:", f);
+import(f).then(async (module) => {
+  const bigConfig = module.default || module;
   const rawConfig = bigConfig.projects[projectName];
+  if (!rawConfig) {
+    console.error(`Project "${projectName}" does not exist in the configuration.`);
+    console.error("Available projects:", Object.keys(bigConfig.projects));
+    process.exit(-1);
+  }
+  if (!rawConfig.tests) {
+    console.error(projectName, "appears to have no tests: ", f);
+    console.error(`here is the config:`);
+    console.log(JSON.stringify(rawConfig));
+    process.exit(-1);
+  }
   const config = {
     ...rawConfig,
     buildDir: process.cwd() + `/testeranto/${projectName}.json`
   };
-  if (!config.tests)
-    throw "config has no tests?";
   const pm = new PM_Main(config, projectName, mode);
   pm.start();
   process.stdin.on("keypress", (str, key) => {