testeranto 0.203.0 → 0.206.0

package/src/app/backend/PM_2_WithTCP.ts

@@ -0,0 +1,286 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { WebSocketMessage } from "../../PM/types.js";
+import { WebSocketServer, WebSocket } from "ws";
+import http from "http";
+import fs from "fs";
+import { getAllFilesRecursively } from "./getAllFilesRecursively.js";
+import { FileService_methods } from "../FileService.js";
+import { ApiEndpoint, ApiFilename } from "../api.js";
+import { PM_1_WithProcesses } from "./PM_1_WithProcesses.js";
+
+export abstract class PM_2_WithTCP extends PM_1_WithProcesses {
+  protected wss: WebSocketServer;
+  protected httpServer: http.Server;
+
+  constructor(configs: any, name: string, mode: string) {
+    super(configs, name, mode);
+
+    console.log("mark2", this.configs);
+    console.log("mark3", configs);
+
+    this.httpServer = http.createServer(this.handleHttpRequest.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 {
+          this.websocket(data, ws);
+        } 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) || 3000;
+    this.httpServer.listen(httpPort, "0.0.0.0", () => {
+      console.log(`HTTP server running on http://localhost:${httpPort}`);
+    });
+  }
+
+  protected websocket(data: any, ws: WebSocket) {
+    try {
+      const wsm: WebSocketMessage = JSON.parse(data.toString());
+
+      FileService_methods.forEach((fsm) => {
+        if (wsm.type === fsm) {
+          this[fsm](wsm, ws);
+        }
+      });
+
+      // Handle other message types
+      if (wsm.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,
+            category: procInfo.category,
+            testName: procInfo.testName,
+            platform: procInfo.platform,
+            logs: this.processLogs.get(id) || [],
+          })
+        );
+        ws.send(
+          JSON.stringify({
+            type: "runningProcesses",
+            processes,
+          })
+        );
+      } else if (wsm.type === "getProcess") {
+        const processId = wsm.data.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,
+              category: procInfo.category,
+              testName: procInfo.testName,
+              platform: procInfo.platform,
+              logs: this.processLogs.get(processId) || [],
+            })
+          );
+        }
+      } else if (wsm.type === "stdin") {
+        const processId = wsm.data.processId;
+        const data = wsm.data.data;
+        const childProcess = this.runningProcesses.get(processId) as any;
+
+        if (childProcess && childProcess.stdin) {
+          childProcess.stdin.write(data);
+        } else {
+          console.log(
+            "Cannot write to stdin - process not found or no stdin:",
+            {
+              processExists: !!childProcess,
+              stdinExists: childProcess?.stdin ? true : false,
+            }
+          );
+        }
+      } else if (wsm.type === "killProcess") {
+        const processId = wsm.processId;
+        console.log("Received killProcess for process", processId);
+        const childProcess = this.runningProcesses.get(processId) as any;
+
+        if (childProcess) {
+          console.log("Killing process");
+          childProcess.kill("SIGTERM");
+        } else {
+          console.log("Cannot kill process - process not found:", {
+            processExists: !!childProcess,
+          });
+        }
+      } else if (wsm.type === "getChatHistory") {
+        if ((this as any).getChatHistory) {
+          (this as any)
+            .getChatHistory()
+            .then((history: any) => {
+              ws.send(
+                JSON.stringify({
+                  type: "chatHistory",
+                  messages: history,
+                })
+              );
+            })
+            .catch((error: any) => {
+              console.error("Error getting chat history:", error);
+              ws.send(
+                JSON.stringify({
+                  type: "error",
+                  message: "Failed to get chat history",
+                })
+              );
+            });
+        }
+      }
+    } catch (error) {
+      console.error("Error handling WebSocket message:", error);
+    }
+  }
+
+  handleHttpRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse<http.IncomingMessage> & {
+      req: http.IncomingMessage;
+    }
+  ) {
+    console.log(req.method, req.url);
+
+    if (req.url === ApiEndpoint.root) {
+      fs.readFile(ApiFilename.root, (err, data) => {
+        if (err) {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end(`500 ${err.toString()}`);
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(data);
+      });
+      return;
+    } else if (req.url === ApiEndpoint.style) {
+      fs.readFile(ApiFilename.style, (err, data) => {
+        if (err) {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end(`500 ${err.toString()}`);
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/css" });
+        res.end(data);
+      });
+      return;
+    } else if (req.url === ApiEndpoint.script) {
+      fs.readFile(ApiFilename.script, (err, data) => {
+        if (err) {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end(`500 ${err.toString()}`);
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/css" });
+        res.end(data);
+        return;
+      });
+      return;
+    } else {
+      res.writeHead(404);
+      res.end(`404 Not Found. ${req.url}`);
+      return;
+    }
+  }
+
+  // FileService methods
+  writeFile_send(wsm: WebSocketMessage, ws: WebSocket) {
+    ws.send(JSON.stringify(["writeFile", wsm.data.path]));
+  }
+
+  writeFile_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    fs.writeFileSync(wsm.data.path, wsm.data.content);
+  }
+
+  readFile_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    this.readFile_send(wsm, ws, fs.readFileSync(wsm.data.path).toString());
+  }
+
+  readFile_send(wsm: WebSocketMessage, ws: WebSocket, content: string) {
+    ws.send(JSON.stringify(["readFile", wsm.data.path, content]));
+  }
+
+  createDirectory_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    fs.mkdirSync(wsm.data.path);
+    this.createDirectory_send(wsm, ws);
+  }
+
+  createDirectory_send(wsm: WebSocketMessage, ws: WebSocket) {
+    ws.send(JSON.stringify(["createDirectory", wsm.data.path]));
+  }
+
+  deleteFile_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    fs.unlinkSync(wsm.data.path);
+    this.deleteFile_send(wsm, ws);
+  }
+
+  deleteFile_send(wsm: WebSocketMessage, ws: WebSocket) {
+    ws.send(JSON.stringify(["deleteFile", wsm.data.path]));
+  }
+
+  async files_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    this.files_send(wsm, ws, await getAllFilesRecursively("."));
+  }
+
+  files_send(wsm: WebSocketMessage, ws: WebSocket, files: string[]) {
+    ws.send(JSON.stringify(["files", files]));
+  }
+
+  projects_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    this.projects_send(
+      wsm,
+      ws,
+      JSON.parse(fs.readFileSync("./testeranto/projects.json", "utf-8"))
+    );
+  }
+
+  projects_send(wsm: WebSocketMessage, ws: WebSocket, projects: object) {
+    ws.send(JSON.stringify(["projects", projects]));
+  }
+
+  report_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    this.report_send(wsm, ws);
+  }
+
+  async report_send(wsm: WebSocketMessage, ws: WebSocket) {
+    // Implementation remains the same
+  }
+
+  async test_receive(wsm: WebSocketMessage, ws: WebSocket) {
+    // Implementation remains the same
+  }
+
+  test_send(wsm: WebSocketMessage, ws: WebSocket, project: string[]) {
+    ws.send(JSON.stringify(["tests", project]));
+  }
+}

package/src/app/backend/PM_WithBuild.ts

@@ -0,0 +1,146 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import esbuild from "esbuild";
+
+import { IBuiltConfig } from "../../Types.js";
+
+import { PM_2_WithTCP } from "./PM_2_WithTCP.js";
+
+export abstract class PM_WithBuild extends PM_2_WithTCP {
+  currentBuildResolve: (() => void) | null = null;
+  currentBuildReject: ((error: any) => void) | null = null;
+
+  async startBuildProcess(
+    configer: (
+      config: IBuiltConfig,
+      entryPoints: string[],
+      testName: string
+    ) => any,
+    entryPoints: Record<string, string>,
+    runtime: string
+  ): Promise<void> {
+    const entryPointKeys = Object.keys(entryPoints);
+    if (entryPointKeys.length === 0) return;
+
+    // Store reference to 'this' for use in the plugin
+    const self = this;
+
+    // Create a custom plugin to track build processes
+    const buildProcessTrackerPlugin = {
+      name: "build-process-tracker",
+      setup(build) {
+        build.onStart(() => {
+          const processId = `build-${runtime}-${Date.now()}`;
+          const command = `esbuild ${runtime} for ${self.projectName}`;
+
+          // Create a promise that will resolve when the build completes
+          const buildPromise = new Promise<void>((resolve, reject) => {
+            // Store resolve and reject functions to call them in onEnd
+            self.currentBuildResolve = resolve;
+            self.currentBuildReject = reject;
+          });
+
+          // Add to process manager
+          if (self.addPromiseProcess) {
+            self.addPromiseProcess(
+              processId,
+              buildPromise,
+              command,
+              "build-time",
+              self.projectName,
+              runtime as any
+            );
+          }
+
+          console.log(
+            `Starting ${runtime} build for ${entryPointKeys.length} entry points`
+          );
+          // Broadcast build start event
+          if (self.webSocketBroadcastMessage) {
+            self.webSocketBroadcastMessage({
+              type: "buildEvent",
+              event: "start",
+              runtime,
+              timestamp: new Date().toISOString(),
+              entryPoints: entryPointKeys.length,
+              processId,
+            });
+          }
+        });
+
+        build.onEnd((result) => {
+          const event = {
+            type: "buildEvent",
+            event: result.errors.length > 0 ? "error" : "success",
+            runtime,
+            timestamp: new Date().toISOString(),
+            errors: result.errors.length,
+            warnings: result.warnings.length,
+          };
+
+          if (result.errors.length > 0) {
+            console.error(
+              `Build ${runtime} failed with ${result.errors.length} errors`
+            );
+            if (self.currentBuildReject) {
+              self.currentBuildReject(
+                new Error(`Build failed with ${result.errors.length} errors`)
+              );
+            }
+          } else {
+            console.log(`Build ${runtime} completed successfully`);
+            if (self.currentBuildResolve) {
+              self.currentBuildResolve();
+            }
+          }
+
+          // Broadcast build result event
+          if (self.webSocketBroadcastMessage) {
+            self.webSocketBroadcastMessage(event);
+          }
+
+          // Clear the current build handlers
+          self.currentBuildResolve = null;
+          self.currentBuildReject = null;
+        });
+      },
+    };
+
+    // Get the base config and add our tracking plugin
+    const baseConfig = configer(this.configs, entryPointKeys, this.projectName);
+    const configWithPlugin = {
+      ...baseConfig,
+      plugins: [...(baseConfig.plugins || []), buildProcessTrackerPlugin],
+    };
+
+    try {
+      // Always build first, then watch if in dev mode
+      if (this.mode === "dev") {
+        const ctx = await esbuild.context(configWithPlugin);
+        // Build once and then watch
+        await ctx.rebuild();
+        await ctx.watch();
+      } else {
+        // In once mode, just build
+        const result = await esbuild.build(configWithPlugin);
+        if (result.errors.length === 0) {
+          console.log(`Successfully built ${runtime} bundle`);
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to build ${runtime}:`, error);
+      // Broadcast error event
+      if (this.webSocketBroadcastMessage) {
+        this.webSocketBroadcastMessage({
+          type: "buildEvent",
+          event: "error",
+          runtime,
+          timestamp: new Date().toISOString(),
+          errors: 1,
+          warnings: 0,
+          message: error.message,
+        });
+      }
+      throw error;
+    }
+  }
+}

package/src/app/backend/PM_WithEslintAndTsc.ts

@@ -0,0 +1,194 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import ts from "typescript";
+import fs from "fs";
+import ansiC from "ansi-colors";
+import { ESLint } from "eslint";
+import tsc from "tsc-prog";
+
+import { lintPather, tscPather } from "./utils";
+import { IBuiltConfig, IRunTime } from "../../Types.js";
+
+import { PM_WithBuild } from "./PM_WithBuild";
+import { IMode } from "../types";
+
+const eslint = new ESLint();
+const formatter = await eslint.loadFormatter(
+  "./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs"
+);
+
+export abstract class PM_WithEslintAndTsc extends PM_WithBuild {
+  constructor(configs: IBuiltConfig, name: string, mode: IMode) {
+    super(configs, name, mode);
+  }
+
+  tscCheck = async ({
+    entrypoint,
+    addableFiles,
+    platform,
+  }: {
+    entrypoint: string;
+    addableFiles: string[];
+    platform: IRunTime;
+  }): Promise<any> => {
+    const processId = `tsc-${entrypoint}-${Date.now()}`;
+    const command = `tsc check for ${entrypoint}`;
+
+    const tscPromise = (async () => {
+      try {
+        this.typeCheckIsRunning(entrypoint);
+      } catch (e) {
+        // Log error through process manager
+        throw new Error(`Error in tscCheck: ${e.message}`);
+      }
+
+      const program = tsc.createProgramFromConfig({
+        basePath: process.cwd(),
+        configFilePath: "tsconfig.json",
+        compilerOptions: {
+          outDir: tscPather(entrypoint, platform, this.projectName),
+          noEmit: true,
+        },
+        include: addableFiles,
+      });
+      const tscPath = tscPather(entrypoint, platform, this.projectName);
+
+      const allDiagnostics = program.getSemanticDiagnostics();
+
+      const results: string[] = [];
+      allDiagnostics.forEach((diagnostic) => {
+        if (diagnostic.file) {
+          const { line, character } = ts.getLineAndCharacterOfPosition(
+            diagnostic.file,
+            diagnostic.start!
+          );
+          const message = ts.flattenDiagnosticMessageText(
+            diagnostic.messageText,
+            "\n"
+          );
+          results.push(
+            `${diagnostic.file.fileName} (${line + 1},${
+              character + 1
+            }): ${message}`
+          );
+        } else {
+          results.push(
+            ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+          );
+        }
+      });
+
+      fs.writeFileSync(tscPath, results.join("\n"));
+      this.typeCheckIsNowDone(entrypoint, results.length);
+      return results.length;
+    })();
+
+    this.addPromiseProcess(
+      processId,
+      tscPromise,
+      command,
+      "build-time",
+      entrypoint
+    );
+  };
+
+  eslintCheck = async ({
+    entrypoint,
+    addableFiles,
+    platform,
+  }: {
+    entrypoint: string;
+    addableFiles: string[];
+    platform: IRunTime;
+  }) => {
+    const processId = `eslint-${entrypoint}-${Date.now()}`;
+    const command = `eslint check for ${entrypoint}`;
+
+    const eslintPromise = (async () => {
+      try {
+        this.lintIsRunning(entrypoint);
+      } catch (e) {
+        throw new Error(`Error in eslintCheck: ${e.message}`);
+      }
+
+      const filepath = lintPather(entrypoint, platform, this.projectName);
+      if (fs.existsSync(filepath)) fs.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;
+        });
+
+      fs.writeFileSync(filepath, await formatter.format(results));
+      this.lintIsNowDone(entrypoint, results.length);
+      return results.length;
+    })();
+
+    this.addPromiseProcess(
+      processId,
+      eslintPromise,
+      command,
+      "build-time",
+      entrypoint
+    );
+  };
+
+  typeCheckIsRunning = (src: string) => {
+    if (!this.summary[src]) {
+      throw `this.summary[${src}] is undefined`;
+    }
+
+    this.summary[src].typeErrors = "?";
+  };
+
+  typeCheckIsNowDone = (src: string, failures: number) => {
+    if (failures === 0) {
+      console.log(ansiC.green(ansiC.inverse(`tsc > ${src}`)));
+    } else {
+      console.log(
+        ansiC.red(ansiC.inverse(`tsc > ${src} failed ${failures} times`))
+      );
+    }
+
+    this.summary[src].typeErrors = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+
+  lintIsRunning = (src: string) => {
+    this.summary[src].staticErrors = "?";
+    this.writeBigBoard();
+  };
+
+  lintIsNowDone = (src: string, failures: number) => {
+    if (failures === 0) {
+      console.log(ansiC.green(ansiC.inverse(`eslint > ${src}`)));
+    } else {
+      console.log(
+        ansiC.red(ansiC.inverse(`eslint > ${src} failed ${failures} times`))
+      );
+    }
+
+    this.summary[src].staticErrors = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+
+  bddTestIsRunning = (src: string) => {
+    this.summary[src].runTimeErrors = "?";
+    this.writeBigBoard();
+  };
+
+  bddTestIsNowDone = (src: string, failures: number) => {
+    this.summary[src].runTimeErrors = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+}