testeranto 0.189.0 → 0.197.0

package/dist/prebuild/ReportServer.mjs

@@ -113,17 +113,115 @@ server.on("error", (err) => {
 process.on("uncaughtException", (err) => {
   console.error("Uncaught exception:", err);
 });
-var start = (port) => {
-  if (port) {
-    server.listen(port, () => {
-      console.log(`Server running on http://localhost:${port}`);
+var start = (port2) => {
+  if (port2) {
+    server.listen(port2, () => {
+      console.log(`Server running on http://localhost:${port2}`);
       console.log("Serving files from:", process.cwd());
     });
   } else {
     console.log("you need to specify a port");
   }
 };
-var ReportServerOfPort = (port) => start(port);
+var ReportServerOfPort = (port2) => start(port2);
+
+// design-editor/server.ts
+import { WebSocketServer } from "ws";
+import fs2 from "fs";
+import path2 from "path";
+var projects = /* @__PURE__ */ new Map();
+function startDesignEditorServer(wssPort2, httpPort) {
+  const wss = new WebSocketServer({ port: wssPort2 });
+  wss.on("connection", (ws, req) => {
+    const url = new URL(req.url || "", `http://${req.headers.host}`);
+    const projectId = url.searchParams.get("project") || "default";
+    if (!projects.has(projectId)) {
+      projects.set(projectId, {
+        connections: /* @__PURE__ */ new Set(),
+        design: loadDesign(projectId)
+      });
+    }
+    const project = projects.get(projectId);
+    project.connections.add(ws);
+    ws.send(
+      JSON.stringify({
+        type: "design_update",
+        data: project.design
+      })
+    );
+    broadcastCollaborators(projectId);
+    ws.on("message", (message) => {
+      const data = JSON.parse(message);
+      if (data.type === "design_update") {
+        project.design = data.data;
+        saveDesign(projectId, data.data);
+        broadcastToProject(projectId, message.toString());
+      }
+    });
+    ws.on("close", (code, reason) => {
+      project.connections.delete(ws);
+      if (project.connections.size === 0) {
+        projects.delete(projectId);
+      } else {
+        broadcastCollaborators(projectId);
+      }
+    });
+  });
+  console.log(`Design editor WebSocket server running on port ${wssPort2}`);
+}
+function broadcastToProject(projectId, message) {
+  const project = projects.get(projectId);
+  if (project) {
+    project.connections.forEach((client) => {
+      if (client.readyState === client.OPEN) {
+        client.send(message);
+      }
+    });
+  }
+}
+function broadcastCollaborators(projectId) {
+  const project = projects.get(projectId);
+  if (project) {
+    const collaborators = Array.from(project.connections).map((_, i) => ({
+      id: `user-${i}`,
+      name: `Collaborator ${i + 1}`
+    }));
+    broadcastToProject(
+      projectId,
+      JSON.stringify({
+        type: "collaborators_update",
+        data: collaborators
+      })
+    );
+  }
+}
+function loadDesign(projectId) {
+  const designsDir = path2.join(process.cwd(), "designs");
+  const filePath = path2.join(designsDir, `${projectId}.json`);
+  try {
+    const data = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return {
+      version: "1.0",
+      background: "#ffffff",
+      objects: []
+    };
+  }
+}
+function saveDesign(projectId, design) {
+  const designsDir = path2.join(process.cwd(), "designs");
+  if (!fs2.existsSync(designsDir)) {
+    fs2.mkdirSync(designsDir, { recursive: true });
+  }
+  const filePath = path2.join(designsDir, `${projectId}.json`);
+  fs2.writeFileSync(filePath, JSON.stringify(design, null, 2));
+}
 
 // src/ReportServer.ts
-ReportServerOfPort(process.argv[2]);
+var port = process.argv[2] || 3e3;
+var wssPort = Number(port) + 1;
+ReportServerOfPort(port);
+startDesignEditorServer(wssPort);
+console.log(`Report server running on http://localhost:${port}`);
+console.log(`Design editor WebSocket running on ws://localhost:${wssPort}`);

package/dist/prebuild/build.mjs

@@ -116,10 +116,9 @@ var register = (entrypoint, sources) => {
   sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
 var inputFilesPlugin_default = (platform, testName2) => {
-  const d = `testeranto/bundles/${platform}/${testName2}/`;
-  const f = `testeranto/bundles/${platform}/${testName2}/metafile.json`;
-  if (!fs.existsSync(d)) {
-    fs.mkdirSync(d);
+  const f = `testeranto/metafiles/${platform}/${testName2}.json`;
+  if (!fs.existsSync(`testeranto/metafiles/${platform}`)) {
+    fs.mkdirSync(`testeranto/metafiles/${platform}`, { recursive: true });
   }
   return {
     register,
@@ -469,7 +468,11 @@ import(process.cwd() + "/testeranto.config.ts").then(async (module) => {
       status = "built";
     }
     if (nodeDone && webDone && importDone && mode === "once") {
-      console.log(ansiC.inverse(`${testName} has been built. Goodbye.`));
+      console.log(
+        ansiC.inverse(
+          `${testName} was built and the builder exited successfully.`
+        )
+      );
       process.exit();
     }
   };

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({});
       });
     });
@@ -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;
@@ -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: {},
@@ -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);
@@ -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;
@@ -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) {

package/dist/types/design-editor/DesignEditor.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface DesignObject {
+    type: string;
+    [key: string]: any;
+}
+interface Design {
+    version: string;
+    background: string;
+    objects: DesignObject[];
+}
+export interface DesignEditorRef {
+    loadDesign: (design: Design) => void;
+    saveDesign: () => Design | null;
+}
+export declare const DesignEditor: React.ForwardRefExoticComponent<{
+    projectId: string;
+} & React.RefAttributes<DesignEditorRef>>;
+export {};

package/dist/types/design-editor/server.d.ts

@@ -0,0 +1 @@
+export declare function startDesignEditorServer(wssPort: number, httpPort?: number): void;

package/dist/types/{PM → src/PM}/index.d.ts

@@ -6,7 +6,7 @@ export declare abstract class PM {
     testResourceConfiguration: ITTestResourceConfiguration;
     abstract start(): Promise<void>;
     abstract stop(): Promise<void>;
-    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
+    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): any;
     abstract $(selector: string, page: string): any;
     abstract click(selector: string): any;
     abstract closePage(p: any): any;