testeranto 0.200.1 → 0.203.0

package/src/services/GitHubAuthService.ts

@@ -0,0 +1,240 @@
+interface GitHubUser {
+  login: string;
+  id: number;
+  avatar_url: string;
+  name: string;
+  email: string;
+}
+
+type EventListener = (...args: any[]) => void;
+
+export class GitHubAuthService {
+  private static get CLIENT_ID(): string | undefined {
+    // Read from the global configuration
+    if (
+      typeof window !== "undefined" &&
+      (window as any).testerantoConfig?.githubOAuth?.clientId
+    ) {
+      return (window as any).testerantoConfig.githubOAuth.clientId;
+    }
+    console.log("GitHub OAuth client ID not found in configuration");
+    return undefined;
+  }
+  private static readonly REDIRECT_URI = `${window.location.origin}/auth/github/callback`;
+  private static readonly SCOPE = "repo user";
+
+  private accessToken: string | null = null;
+  private user: GitHubUser | null = null;
+  private listeners: Map<string, EventListener[]> = new Map();
+
+  constructor() {
+    this.loadStoredAuth();
+  }
+
+  on(event: string, listener: EventListener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)!.push(listener);
+  }
+
+  off(event: string, listener: EventListener) {
+    const eventListeners = this.listeners.get(event);
+    if (eventListeners) {
+      const index = eventListeners.indexOf(listener);
+      if (index > -1) {
+        eventListeners.splice(index, 1);
+      }
+    }
+  }
+
+  emit(event: string, ...args: any[]) {
+    const eventListeners = this.listeners.get(event);
+    if (eventListeners) {
+      eventListeners.forEach((listener) => {
+        try {
+          listener(...args);
+        } catch (error) {
+          console.error(`Error in event listener for ${event}:`, error);
+        }
+      });
+    }
+  }
+
+  private loadStoredAuth() {
+    const token = localStorage.getItem("github_access_token");
+    const userStr = localStorage.getItem("github_user");
+
+    if (token) {
+      this.accessToken = token;
+    }
+
+    if (userStr) {
+      this.user = JSON.parse(userStr);
+    }
+  }
+
+  get isAuthenticated(): boolean {
+    return !!this.accessToken;
+  }
+
+  get userInfo(): GitHubUser | null {
+    return this.user;
+  }
+
+  get token(): string | null {
+    return this.accessToken;
+  }
+
+  initiateLogin() {
+    const clientId = GitHubAuthService.CLIENT_ID;
+    console.log("Initiating login with CLIENT_ID:", clientId);
+
+    if (!clientId) {
+      console.error(
+        "GitHub OAuth client ID is not configured. Please set GITHUB_CLIENT_ID environment variable."
+      );
+
+      // Provide helpful instructions for setup
+      const setupInstructions = `
+GitHub authentication is not configured.
+
+To set up GitHub OAuth:
+
+1. Go to https://github.com/settings/developers
+2. Create a new OAuth App
+3. Set Authorization callback URL to: ${GitHubAuthService.REDIRECT_URI}
+4. Add GITHUB_CLIENT_ID to your environment variables
+5. Restart the development server
+
+For development, you can create a .env file in the root directory with:
+GITHUB_CLIENT_ID=your_client_id_here
+
+Current environment analysis:
+- process.env.GITHUB_CLIENT_ID: ${
+        typeof process !== "undefined"
+          ? process.env?.GITHUB_CLIENT_ID || "undefined"
+          : "process undefined"
+      }
+- window.env.GITHUB_CLIENT_ID: ${
+        typeof window !== "undefined"
+          ? (window as any).env?.GITHUB_CLIENT_ID || "undefined"
+          : "window undefined"
+      }
+      `;
+
+      alert(setupInstructions);
+      return;
+    }
+    const authUrl = `https://github.com/login/oauth/authorize?client_id=${clientId}&redirect_uri=${encodeURIComponent(
+      GitHubAuthService.REDIRECT_URI
+    )}&scope=${encodeURIComponent(GitHubAuthService.SCOPE)}`;
+    console.log("Opening auth popup:", authUrl);
+    
+    // Open in a popup window
+    const width = 600;
+    const height = 700;
+    const left = (window.screen.width - width) / 2;
+    const top = (window.screen.height - height) / 2;
+    
+    window.open(
+      authUrl,
+      'github-auth',
+      `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`
+    );
+  }
+
+  async handleCallback(code: string): Promise<boolean> {
+    try {
+      const response = await fetch("/api/auth/github/token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ code }),
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to exchange code for token");
+      }
+
+      const data = await response.json();
+      this.accessToken = data.access_token;
+
+      // Store token
+      localStorage.setItem("github_access_token", this.accessToken);
+
+      // Get user info
+      await this.fetchUserInfo();
+
+      this.emit("authChange", true);
+      return true;
+    } catch (error) {
+      console.error("Authentication failed:", error);
+      this.logout();
+      return false;
+    }
+  }
+
+  private async fetchUserInfo() {
+    if (!this.accessToken) return;
+
+    try {
+      const response = await fetch("https://api.github.com/user", {
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+          Accept: "application/vnd.github.v3+json",
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error("Failed to fetch user info");
+      }
+
+      this.user = await response.json();
+      localStorage.setItem("github_user", JSON.stringify(this.user));
+    } catch (error) {
+      console.error("Failed to fetch user info:", error);
+    }
+  }
+
+  logout() {
+    this.accessToken = null;
+    this.user = null;
+    localStorage.removeItem("github_access_token");
+    localStorage.removeItem("github_user");
+    this.emit("authChange", false);
+  }
+
+  isConfigured(): boolean {
+    const clientId = GitHubAuthService.CLIENT_ID;
+    console.log("Checking if configured - CLIENT_ID:", clientId);
+    return !!clientId;
+  }
+
+  async makeAuthenticatedRequest(url: string, options: RequestInit = {}) {
+    if (!this.accessToken) {
+      throw new Error("Not authenticated");
+    }
+
+    const headers = {
+      Authorization: `Bearer ${this.accessToken}`,
+      Accept: "application/vnd.github.v3+json",
+      ...options.headers,
+    };
+
+    const response = await fetch(url, {
+      ...options,
+      headers,
+    });
+
+    if (response.status === 401) {
+      this.logout();
+      throw new Error("Authentication expired");
+    }
+
+    return response;
+  }
+}
+
+export const githubAuthService = new GitHubAuthService();

package/src/testeranto.ts

@@ -1,21 +1,28 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
+
 import ansiC from "ansi-colors";
 import fs from "fs";
-import path from "path";
 import readline from "readline";
-import esbuild from "esbuild";
 
-import { ITestconfig, IRunTime, ITestTypes, IBuiltConfig } from "./lib";
+import { ITestconfig, IRunTime, IBuiltConfig } from "./lib";
 import { IProject } from "./Types";
 import { getRunnables } from "./utils";
 import { AppHtml } from "./utils/buildTemplates";
 
-import esbuildNodeConfiger from "./esbuildConfigs/node";
-import esbuildWebConfiger from "./esbuildConfigs/web";
-import esbuildImportConfiger from "./esbuildConfigs/pure";
-import webHtmlFrame from "./web.html";
 import { PM_Main } from "./PM/main";
+import { PitonoBuild } from "./PM/pitonoBuild";
+const { GolingvuBuild } = await import("./PM/golingvuBuild");
+
+// if (!process.env.GITHUB_CLIENT_ID) {
+//   console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
+//   process.exit(-1);
+// }
+
+// if (!process.env.GITHUB_CLIENT_SECRET) {
+//   console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
+//   process.exit(-1);
+// }
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -28,11 +35,9 @@ if (mode !== "once" && mode !== "dev") {
   process.exit(-1);
 }
 
-const f = process.cwd() + "/" + "testeranto.config.ts";
-
-console.log("config file:", f);
+const configFilePath = process.cwd() + "/" + "testeranto.config.ts";
 
-import(f).then(async (module) => {
+import(configFilePath).then(async (module) => {
   const pckge = (await import(`${process.cwd()}/package.json`)).default;
   const bigConfig: IProject = module.default;
 
@@ -42,10 +47,15 @@ import(f).then(async (module) => {
     process.exit(-1);
   }
 
-  fs.writeFileSync(
-    `${process.cwd()}/testeranto/projects.json`,
-    JSON.stringify(Object.keys(bigConfig.projects), null, 2)
-  );
+  try {
+    fs.writeFileSync(
+      `${process.cwd()}/testeranto/projects.json`,
+      JSON.stringify(Object.keys(bigConfig.projects), null, 2)
+    );
+  } catch (e) {
+    console.error("there was a problem");
+    console.error(e);
+  }
 
   const rawConfig: ITestconfig = bigConfig.projects[testName];
 
@@ -56,7 +66,7 @@ import(f).then(async (module) => {
   }
 
   if (!rawConfig.tests) {
-    console.error(testName, "appears to have no tests: ", f);
+    console.error(testName, "appears to have no tests: ", configFilePath);
     console.error(`here is the config:`);
     console.log(JSON.stringify(rawConfig));
     process.exit(-1);
@@ -77,84 +87,18 @@ import(f).then(async (module) => {
     }
   });
 
-  let nodeDone: boolean = false;
-  let webDone: boolean = false;
-  let importDone: boolean = false;
-  let golangDone: boolean = false;
-  let pitonoDone: boolean = false;
-
-  let status: "build" | "built" = "build";
-
-  const {
-    nodeEntryPoints,
-    nodeEntryPointSidecars,
-    webEntryPoints,
-    webEntryPointSidecars,
-    pureEntryPoints,
-    pureEntryPointSidecars,
-  } = getRunnables(config.tests, testName);
-
-  const onNodeDone = () => {
-    nodeDone = true;
-    onDone();
-  };
-
-  const onWebDone = () => {
-    webDone = true;
-    onDone();
-  };
-
-  const onImportDone = () => {
-    importDone = true;
-    onDone();
-  };
-
-  const onGolangDone = () => {
-    golangDone = true;
-    onDone();
-  };
-
-  const onPitonoDone = () => {
-    pitonoDone = true;
-    onDone();
-  };
+  //////////////////////////////////////////////////////////////////////////////////////////////////
 
   let pm: PM_Main | null = null;
-  const onDone = async () => {
-    // Check which test types are present
-    const hasGolangTests = config.tests.some(test => test[1] === 'golang');
-    const hasPitonoTests = config.tests.some(test => test[1] === 'pitono');
-    
-    // Wait for all relevant runtimes to be done
-    const allDone = 
-      nodeDone && webDone && importDone && 
-      (!hasGolangTests || golangDone) && 
-      (!hasPitonoTests || pitonoDone);
-      
-    if (allDone) {
-      status = "built";
-
-      // Start the PM_Main to run the tests after build
-      if (!pm) {
-        const { PM_Main } = await import("./PM/main");
-        pm = new PM_Main(config, testName, mode);
-        await pm.start();
-      }
-    }
-    if (allDone && mode === "once") {
-      console.log(
-        ansiC.inverse(
-          `${testName} was built and the builder exited successfully.`
-        )
-      );
-      // Let PM_Main handle the exit after tests are complete
-    }
-  };
+  // Start PM_Main immediately - it will handle the build processes internally
+  const { PM_Main } = await import("./PM/main");
+  pm = new PM_Main(config, testName, mode);
+  await pm.start();
 
   fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
 
   Object.keys(bigConfig.projects).forEach((projectName) => {
-    console.log(`testeranto/reports/${projectName}`);
+    // console.log(`testeranto/reports/${projectName}`);
     if (!fs.existsSync(`testeranto/reports/${projectName}`)) {
       fs.mkdirSync(`testeranto/reports/${projectName}`);
     }
@@ -165,182 +109,126 @@ import(f).then(async (module) => {
     );
   });
 
-  const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
-    const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
-      ts.forEach((t) => {
-        if (t[1] === runtime) {
-          st.add(t[0]);
-        }
-        if (Array.isArray(t[3])) {
-          meta(t[3], st);
-        }
-      });
-      return st;
-    };
-    return Array.from(meta(config.tests, new Set()));
-  };
+  // const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
+  //   const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+  //     ts.forEach((t) => {
+  //       if (t[1] === runtime) {
+  //         st.add(t[0]);
+  //       }
+  //       if (Array.isArray(t[3])) {
+  //         meta(t[3], st);
+  //       }
+  //     });
+  //     return st;
+  //   };
+  //   return Array.from(meta(config.tests, new Set()));
+  // };
 
   // Also handle pitono endpoints for HTML generation if needed
-  [...getSecondaryEndpointsPoints("pitono")].forEach(async (sourceFilePath) => {
-    // You might want to generate specific files for pitono tests here
-    console.log(`Pitono test found: ${sourceFilePath}`);
-  });
+  // [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
+  //   // You might want to generate specific files for pitono tests here
+  //   console.log(`Pitono test found: ${sourceFilePath}`);
+  // });
+
+  // Promise.resolve(
+  //   Promise.all(
+  //     [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+  //       const sourceFileSplit = sourceFilePath.split("/");
+  //       const sourceDir = sourceFileSplit.slice(0, -1);
+  //       const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+  //       const sourceFileNameMinusJs = sourceFileName
+  //         .split(".")
+  //         .slice(0, -1)
+  //         .join(".");
+
+  //       const htmlFilePath = path.normalize(
+  //         `${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join(
+  //           "/"
+  //         )}/${sourceFileNameMinusJs}.html`
+  //       );
+  //       const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+  //       const cssFilePath = `./${sourceFileNameMinusJs}.css`;
+
+  //       return fs.promises
+  //         .mkdir(path.dirname(htmlFilePath), { recursive: true })
+  //         .then((x) =>
+  //           fs.writeFileSync(
+  //             htmlFilePath,
+  //             webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)
+  //           )
+  //         );
+  //     })
+  //   )
+  // );
 
-  // Handle golang tests by generating their metafiles
-  const golangTests = config.tests.filter(test => test[1] === 'golang');
+  const {
+    nodeEntryPoints,
+    nodeEntryPointSidecars,
+    webEntryPoints,
+    webEntryPointSidecars,
+    pureEntryPoints,
+    pureEntryPointSidecars,
+    pythonEntryPoints,
+    pythonEntryPointSidecars,
+    golangEntryPoints,
+    golangEntryPointSidecars,
+  } = getRunnables(config.tests, testName);
+  
+  // Debug logging to check if entry points are being found
+  console.log("Node entry points:", Object.keys(nodeEntryPoints));
+  console.log("Web entry points:", Object.keys(webEntryPoints));
+  console.log("Pure entry points:", Object.keys(pureEntryPoints));
+
+  // Handle golang tests using GolingvuBuild
+  const golangTests = config.tests.filter((test) => test[1] === "golang");
   const hasGolangTests = golangTests.length > 0;
   if (hasGolangTests) {
-    // Import and use the golang metafile utilities
-    const { generateGolangMetafile, writeGolangMetafile } = await import('./utils/golingvuMetafile');
-    // Get the entry points (first element of each test tuple)
-    const golangEntryPoints = golangTests.map(test => test[0]);
-    const metafile = await generateGolangMetafile(testName, golangEntryPoints);
-    writeGolangMetafile(testName, metafile);
-    // Mark golang as done after writing the metafile
-    onGolangDone();
+    const golingvuBuild = new GolingvuBuild(config, testName);
+    const golangEntryPoints = await golingvuBuild.build();
+    golingvuBuild.onBundleChange(() => {
+      Object.keys(golangEntryPoints).forEach((entryPoint) => {
+        if (pm) {
+          pm.addToQueue(entryPoint, "golang");
+        }
+      });
+    });
   }
 
   // Handle pitono (Python) tests by generating their metafiles
-  const pitonoTests = config.tests.filter(test => test[1] === 'pitono');
+  const pitonoTests = config.tests.filter((test) => test[1] === "python");
   const hasPitonoTests = pitonoTests.length > 0;
   if (hasPitonoTests) {
-    // Import and use the pitono metafile utilities
-    const { generatePitonoMetafile } = await import('./utils/pitonoMetafile');
-    // Get the entry points (first element of each test tuple)
-    const pitonoEntryPoints = pitonoTests.map(test => test[0]);
-    const metafile = await generatePitonoMetafile(testName, pitonoEntryPoints);
-    
-    // Ensure the directory exists
-    const pitonoMetafilePath = `${process.cwd()}/testeranto/metafiles/python`;
-    await fs.promises.mkdir(pitonoMetafilePath, { recursive: true });
-    
-    // Write the metafile to the specified path
-    fs.writeFileSync(
-      `${pitonoMetafilePath}/core.json`,
-      JSON.stringify(metafile, null, 2)
-    );
-    
-    // Mark pitono as done after writing the metafile
-    onPitonoDone();
+    const pitonoBuild = new PitonoBuild(config, testName);
+    const pitonoEntryPoints = await pitonoBuild.build();
+    pitonoBuild.onBundleChange(() => {
+      Object.keys(pitonoEntryPoints).forEach((entryPoint) => {
+        if (pm) {
+          pm.addToQueue(entryPoint, "python");
+        }
+      });
+    });
   }
 
-  Promise.resolve(
-    Promise.all(
-      [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
-        const sourceFileSplit = sourceFilePath.split("/");
-        const sourceDir = sourceFileSplit.slice(0, -1);
-        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
-        const sourceFileNameMinusJs = sourceFileName
-          .split(".")
-          .slice(0, -1)
-          .join(".");
-
-        const htmlFilePath = path.normalize(
-          `${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join(
-            "/"
-          )}/${sourceFileNameMinusJs}.html`
-        );
-        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
-
-        return fs.promises
-          .mkdir(path.dirname(htmlFilePath), { recursive: true })
-          .then((x) =>
-            fs.writeFileSync(
-              htmlFilePath,
-              webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)
-            )
-          );
-      })
-    )
-  );
-
-  const x: [IRunTime, string[]][] = [
+  // create the necessary folders for all tests
+  [
     ["pure", Object.keys(pureEntryPoints)],
     ["node", Object.keys(nodeEntryPoints)],
     ["web", Object.keys(webEntryPoints)],
-  ];
-
-  x.forEach(async ([runtime, keys]) => {
+    ["python", Object.keys(pythonEntryPoints)],
+    ["golang", Object.keys(golangEntryPoints)],
+  ].forEach(async ([runtime, keys]: [IRunTime, string[]]) => {
     keys.forEach(async (k) => {
-      const folder = `testeranto/reports/${testName}/${k
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/${runtime}`;
-
-      await fs.mkdirSync(folder, { recursive: true });
+      fs.mkdirSync(
+        `testeranto/reports/${testName}/${k
+          .split(".")
+          .slice(0, -1)
+          .join(".")}/${runtime}`,
+        { recursive: true }
+      );
     });
   });
 
-  [
-    [pureEntryPoints, pureEntryPointSidecars, "pure"],
-    [webEntryPoints, webEntryPointSidecars, "web"],
-    [nodeEntryPoints, nodeEntryPointSidecars, "node"],
-  ].forEach(
-    ([eps, eps2, runtime]: [
-      Record<string, string>,
-      Record<string, string>,
-      IRunTime
-    ]) => {
-      [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
-        const fp = path.resolve(
-          `testeranto`,
-          `reports`,
-          testName,
-          ep.split(".").slice(0, -1).join("."),
-          runtime
-        );
-        fs.mkdirSync(fp, { recursive: true });
-      });
-    }
-  );
-
-  await Promise.all([
-    ...(
-      [
-        [
-          esbuildImportConfiger,
-          pureEntryPoints,
-          pureEntryPointSidecars,
-          onImportDone,
-        ],
-        [
-          esbuildNodeConfiger,
-          nodeEntryPoints,
-          nodeEntryPointSidecars,
-          onNodeDone,
-        ],
-        [esbuildWebConfiger, webEntryPoints, webEntryPointSidecars, onWebDone],
-      ] as [
-        (a, b, c) => any,
-        Record<string, string>,
-        Record<string, string>,
-        () => void
-      ][]
-    ).map(([configer, entryPoints, sidecars, done]) => {
-      esbuild
-        .context(
-          configer(
-            config,
-            [...Object.keys(entryPoints), ...Object.keys(sidecars)],
-            testName
-          )
-        )
-        .then(async (ctx) => {
-          if (mode === "dev") {
-            await ctx.watch().then((v) => {
-              done();
-            });
-          } else {
-            ctx.rebuild().then((v) => {
-              done();
-            });
-          }
-
-          return ctx;
-        });
-    }),
-  ]);
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {