testeranto 0.203.0 → 0.206.0

package/dist/common/src/app/frontend/GitFileService.js

@@ -0,0 +1,262 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitFileService = void 0;
+// import { buffer } from "stream/consumers";
+const FileService_1 = require("../FileService");
+class GitFileService extends FileService_1.FileService {
+    constructor() {
+        super(...arguments);
+        this.git = null;
+        this.fs = null;
+        this.dir = "/testeranto-git";
+    }
+    files(path) {
+        throw new Error("Method not implemented.");
+    }
+    projects(project) {
+        throw new Error("Method not implemented.");
+    }
+    tests(project) {
+        throw new Error("Method not implemented.");
+    }
+    report(project, test) {
+        throw new Error("Method not implemented.");
+    }
+    fsTree(path) {
+        throw new Error("Method not implemented.");
+    }
+    projectTree(project) {
+        throw new Error("Method not implemented.");
+    }
+    async ensureGit() {
+        // if (!this.git && typeof window !== "undefined") {
+        //   // Dynamically import isomorphic-git only in browser environment
+        //   // this.git = await import("isomorphic-git");
+        //   // this.fs = await import("isomorphic-git/http/web");
+        // }
+    }
+    async ensureBufferPolyfill() {
+        if (typeof window !== "undefined" && !window.Buffer) {
+            try {
+                // const buffer = await import("buffer");
+                window.Buffer = buffer.Buffer;
+            }
+            catch (error) {
+                console.warn("Buffer polyfill not available:", error);
+            }
+        }
+    }
+    async readFile(path) {
+        // Only run in browser environment
+        if (typeof window === "undefined") {
+            throw new Error("GitFileService is only available in browser environment");
+        }
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            const content = await this.git.readBlob({
+                fs: window.fs,
+                dir: this.dir,
+                oid: await this.git.resolveRef({
+                    fs: window.fs,
+                    dir: this.dir,
+                    ref: "HEAD",
+                }),
+                filepath: path,
+            });
+            return new TextDecoder().decode(content.blob);
+        }
+        catch (error) {
+            throw new Error(`Failed to read file: ${path}`);
+        }
+    }
+    async readDirectory(path) {
+        // Only run in browser environment
+        if (typeof window === "undefined") {
+            return [];
+        }
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            const files = await this.git.listFiles({
+                fs: window.fs,
+                dir: this.dir,
+                ref: "HEAD",
+            });
+            return files.map((name) => ({
+                name,
+                path: name,
+                type: name.includes(".") ? "file" : "directory",
+            }));
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    async exists(path) {
+        try {
+            await this.readFile(path);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async writeFile(path, content) {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        // In Git mode, files are written to the virtual file system
+        // This would need proper implementation with IndexedDB or similar
+        console.log("Git mode write:", path);
+    }
+    async createDirectory(path) {
+        // Directories are created automatically when writing files
+        console.log("Git mode create directory:", path);
+    }
+    async deleteFile(path) {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        // Mark file for deletion in next commit
+        console.log("Git mode delete:", path);
+    }
+    async getFileStatus(path) {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            const status = await this.git.status({
+                fs: window.fs,
+                dir: this.dir,
+                filepath: path,
+            });
+            return { status: status };
+        }
+        catch (_a) {
+            return { status: "unchanged" };
+        }
+    }
+    async getChanges() {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            const statusMatrix = await this.git.statusMatrix({
+                fs: window.fs,
+                dir: this.dir,
+            });
+            return statusMatrix
+                .map(([file, head, workdir, stage]) => {
+                let status = "unchanged";
+                if (head === 0 && workdir === 2)
+                    status = "added";
+                else if (head === 1 && workdir === 0)
+                    status = "deleted";
+                else if (workdir === 2)
+                    status = "modified";
+                else if (head !== workdir)
+                    status = "modified";
+                return { path: file, status };
+            })
+                .filter((change) => change.status !== "unchanged");
+        }
+        catch (error) {
+            console.warn("Failed to get changes:", error);
+            return [];
+        }
+    }
+    async commitChanges(message, description) {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            // Stage all changes
+            const changes = await this.getChanges();
+            for (const change of changes) {
+                if (change.status === "deleted") {
+                    await this.git.remove({
+                        fs: window.fs,
+                        dir: this.dir,
+                        filepath: change.path,
+                    });
+                }
+                else {
+                    await this.git.add({
+                        fs: window.fs,
+                        dir: this.dir,
+                        filepath: change.path,
+                    });
+                }
+            }
+            // Commit
+            await this.git.commit({
+                fs: window.fs,
+                dir: this.dir,
+                author: { name: "Testeranto User", email: "user@testeranto" },
+                message: description ? `${message}\n\n${description}` : message,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to commit changes: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async pushChanges() {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            await this.git.push({
+                fs: window.fs,
+                http: this.fs,
+                dir: this.dir,
+                remote: "origin",
+                ref: "main",
+                onAuth: () => ({ username: "token" }),
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to push changes: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async pullChanges() {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            await this.git.pull({
+                fs: window.fs,
+                http: this.fs,
+                dir: this.dir,
+                remote: "origin",
+                ref: "main",
+                singleBranch: true,
+                onAuth: () => ({ username: "token" }),
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to pull changes: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async getCurrentBranch() {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            return ((await this.git.currentBranch({
+                fs: window.fs,
+                dir: this.dir,
+            })) || "main");
+        }
+        catch (_a) {
+            return "main";
+        }
+    }
+    async getRemoteStatus() {
+        await this.ensureBufferPolyfill();
+        await this.ensureGit();
+        try {
+            // For now, return mock data
+            // In a real implementation, we'd compare local and remote branches
+            return { ahead: 0, behind: 0 };
+        }
+        catch (_a) {
+            return { ahead: 0, behind: 0 };
+        }
+    }
+}
+exports.GitFileService = GitFileService;

package/dist/common/src/app/frontend/GitHubAuthService.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubAuthService = exports.GitHubAuthService = void 0;
+class GitHubAuthService {
+    static get CLIENT_ID() {
+        var _a, _b;
+        // Read from the global configuration
+        if (typeof window !== "undefined" &&
+            ((_b = (_a = window.testerantoConfig) === null || _a === void 0 ? void 0 : _a.githubOAuth) === null || _b === void 0 ? void 0 : _b.clientId)) {
+            return window.testerantoConfig.githubOAuth.clientId;
+        }
+        console.log("GitHub OAuth client ID not found in configuration");
+        return undefined;
+    }
+    constructor() {
+        this.accessToken = null;
+        this.user = null;
+        this.listeners = new Map();
+        this.loadStoredAuth();
+    }
+    on(event, listener) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, []);
+        }
+        this.listeners.get(event).push(listener);
+    }
+    off(event, listener) {
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) {
+            const index = eventListeners.indexOf(listener);
+            if (index > -1) {
+                eventListeners.splice(index, 1);
+            }
+        }
+    }
+    emit(event, ...args) {
+        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);
+                }
+            });
+        }
+    }
+    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() {
+        return !!this.accessToken;
+    }
+    get userInfo() {
+        return this.user;
+    }
+    get token() {
+        return this.accessToken;
+    }
+    initiateLogin() {
+        var _a, _b;
+        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"
+                ? ((_a = process.env) === null || _a === void 0 ? void 0 : _a.GITHUB_CLIENT_ID) || "undefined"
+                : "process undefined"}
+- window.env.GITHUB_CLIENT_ID: ${typeof window !== "undefined"
+                ? ((_b = window.env) === null || _b === void 0 ? void 0 : _b.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) {
+        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;
+        }
+    }
+    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() {
+        const clientId = GitHubAuthService.CLIENT_ID;
+        console.log("Checking if configured - CLIENT_ID:", clientId);
+        return !!clientId;
+    }
+    async makeAuthenticatedRequest(url, options = {}) {
+        if (!this.accessToken) {
+            throw new Error("Not authenticated");
+        }
+        const headers = Object.assign({ Authorization: `Bearer ${this.accessToken}`, Accept: "application/vnd.github.v3+json" }, options.headers);
+        const response = await fetch(url, Object.assign(Object.assign({}, options), { headers }));
+        if (response.status === 401) {
+            this.logout();
+            throw new Error("Authentication expired");
+        }
+        return response;
+    }
+}
+exports.GitHubAuthService = GitHubAuthService;
+GitHubAuthService.REDIRECT_URI = `${window.location.origin}/auth/github/callback`;
+GitHubAuthService.SCOPE = "repo user";
+exports.githubAuthService = new GitHubAuthService();

package/dist/common/src/app/frontend/api.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summaryDotJson = exports.fetchTestData = exports.fetchProjectData = void 0;
+const logFiles_1 = require("../../utils/logFiles");
+const fetchProjectData = async (projectName) => {
+    const [summaryRes, configRes] = await Promise.all([
+        fetch((0, exports.summaryDotJson)(projectName)),
+        fetch("/reports/config.json"),
+    ]);
+    return {
+        summary: (await summaryRes.json()),
+        config: (await configRes.json()),
+    };
+};
+exports.fetchProjectData = fetchProjectData;
+const fetchTestData = async (projectName, filepath, runTime) => {
+    const basePath = `reports/${projectName}/${filepath
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/${runTime}`;
+    try {
+        const logFiles = (0, logFiles_1.getLogFilesForRuntime)(runTime);
+        const logs = {};
+        // Fetch all log files in parallel
+        const logRequests = logFiles.map(async (file) => {
+            try {
+                const response = await fetch(`${basePath}/${file}`);
+                if (!response.ok)
+                    return null;
+                const content = file.endsWith(".json")
+                    ? await response.json()
+                    : await response.text();
+                return { file, content };
+            }
+            catch (err) {
+                console.error(`Failed to fetch ${file}:`, err);
+                return null;
+            }
+        });
+        // Wait for all requests and populate logs
+        const logResults = await Promise.all(logRequests);
+        logResults.forEach((result) => {
+            if (result) {
+                logs[result.file] = result.content;
+            }
+        });
+        // Ensure we fetch all standard logs
+        for (const file of Object.values(logFiles_1.STANDARD_LOGS)) {
+            if (!logs[file]) {
+                try {
+                    const response = await fetch(`${basePath}/${file}`);
+                    if (response.ok) {
+                        logs[file] = file.endsWith(".json")
+                            ? await response.json()
+                            : await response.text();
+                    }
+                }
+                catch (err) {
+                    console.error(`Failed to fetch ${file}:`, err);
+                }
+            }
+        }
+        // const logs = await logFiles.reduce(async (acc, file, i) => {
+        //   acc[file.split(".")[0]] = await logRes[i].text();
+        //   return acc;
+        // }, {});
+        // Check if we got any logs at all
+        if (Object.keys(logs).length === 0) {
+            return {
+                logs: {},
+                error: "No test logs found. The test may not have run or the report files are missing.",
+            };
+        }
+        return {
+            logs,
+            error: null,
+        };
+    }
+    catch (err) {
+        return {
+            // testData: null,
+            logs: {},
+            // typeErrors: "",
+            // lintErrors: "",
+            error: `Failed to load test data: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+};
+exports.fetchTestData = fetchTestData;
+const summaryDotJson = (name) => {
+    return `reports/${name}/summary.json`;
+};
+exports.summaryDotJson = summaryDotJson;