testeranto 0.202.0 → 0.205.0

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

@@ -0,0 +1,258 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// import { buffer } from "stream/consumers";
+import { FileService, } from "../FileService";
+export class GitFileService extends 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 };
+        }
+    }
+}

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

@@ -0,0 +1,180 @@
+export 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;
+    }
+}
+GitHubAuthService.REDIRECT_URI = `${window.location.origin}/auth/github/callback`;
+GitHubAuthService.SCOPE = "repo user";
+export const githubAuthService = new GitHubAuthService();

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

@@ -0,0 +1,87 @@
+import { getLogFilesForRuntime, STANDARD_LOGS } from "../../utils/logFiles";
+export const fetchProjectData = async (projectName) => {
+    const [summaryRes, configRes] = await Promise.all([
+        fetch(summaryDotJson(projectName)),
+        fetch("/reports/config.json"),
+    ]);
+    return {
+        summary: (await summaryRes.json()),
+        config: (await configRes.json()),
+    };
+};
+export const fetchTestData = async (projectName, filepath, runTime) => {
+    const basePath = `reports/${projectName}/${filepath
+        .split(".")
+        .slice(0, -1)
+        .join(".")}/${runTime}`;
+    try {
+        const logFiles = 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(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)}`,
+        };
+    }
+};
+export const summaryDotJson = (name) => {
+    return `reports/${name}/summary.json`;
+};

package/dist/module/src/app/frontend/components/DesignEditorPage.js

@@ -0,0 +1,171 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import React, { useState } from 'react';
+import { Button, Container, Row, Col } from 'react-bootstrap';
+import { saveAs } from 'file-saver';
+export const DesignEditorPage = () => {
+    const [projectId, setProjectId] = useState('default-project');
+    const [fileHandle, setFileHandle] = useState(null);
+    const handleSave = async () => {
+        try {
+            // if (!designEditorRef.current) {
+            //   console.warn('Design editor ref not available');
+            //   return;
+            // }
+            // Get and save current design state
+            // const designData = designEditorRef.current.saveDesign();
+            // if (!designData) {
+            //   console.warn('No design data to save');
+            //   return;
+            // }
+            // Include projectId in the saved data
+            // const fullDesign = {
+            //   ...designData,
+            //   projectId
+            // };
+            // Force immediate render after save
+            // if (designEditorRef.current) {
+            //   designEditorRef.current.loadDesign(fullDesign);
+            // }
+            let newHandle;
+            if ('showSaveFilePicker' in window && window.showSaveFilePicker) {
+                try {
+                    newHandle = await window.showSaveFilePicker({
+                        types: [{
+                                description: 'Design Files',
+                                accept: {
+                                    'application/json': ['.json'],
+                                },
+                            }],
+                        suggestedName: `${projectId}.json`
+                    });
+                }
+                catch (err) {
+                    console.warn('Error using showSaveFilePicker:', err);
+                    // Fall back to traditional download
+                    // const jsonData = JSON.stringify(fullDesign, null, 2);
+                    // const blob = new Blob([jsonData], { type: 'application/json' });
+                    // const url = URL.createObjectURL(blob);
+                    // const a = document.createElement('a');
+                    // a.href = url;
+                    // a.download = `${projectId}.json`;
+                    // a.click();
+                    // URL.revokeObjectURL(url);
+                    return;
+                }
+            }
+            else {
+                // Fall back to traditional download
+                // const jsonData = JSON.stringify(fullDesign, null, 2);
+                // const blob = new Blob([jsonData], { type: 'application/json' });
+                // const url = URL.createObjectURL(blob);
+                // const a = document.createElement('a');
+                // a.href = url;
+                // a.download = `${projectId}.json`;
+                // a.click();
+                // URL.revokeObjectURL(url);
+                return;
+            }
+            // const jsonData = JSON.stringify(fullDesign, null, 2);
+            // const writable = await newHandle.createWritable();
+            // await writable.write(jsonData);
+            // await writable.close();
+            // setFileHandle(newHandle);
+            // console.log('Design saved successfully:', fullDesign);
+        }
+        catch (err) {
+            console.error('Error saving file:', err);
+            if (err instanceof Error) {
+                console.error('Error details:', {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack
+                });
+            }
+        }
+    };
+    const [design, setDesign] = useState(null);
+    // const designEditorRef = useRef<DesignEditorRef>(null);
+    const handleOpen = async () => {
+        console.log('handleOpen triggered');
+        try {
+            // if (!window.showOpenFilePicker) {
+            //   throw new Error('File System Access API not supported in this browser');
+            // }
+            console.log('Attempting to show file picker...');
+            let handle;
+            if ('showOpenFilePicker' in window) {
+                // @ts-ignore
+                [handle] = await window.showOpenFilePicker({
+                    types: [{
+                            description: 'Design Files',
+                            accept: {
+                                'application/json': ['.json'],
+                            },
+                        }],
+                    multiple: false
+                });
+            }
+            else {
+                throw new Error('File System Access API not supported');
+            }
+            if (!handle) {
+                throw new Error('No file selected');
+            }
+            console.log('File handle obtained:', handle);
+            const file = await handle.getFile();
+            console.log('File object obtained:', file);
+            const contents = await file.text();
+            console.log('File contents loaded, length:', contents.length);
+            let loadedDesign = JSON.parse(contents);
+            console.log('Design parsed successfully:', loadedDesign);
+            // Ensure design has proper structure
+            if (!loadedDesign.objects || !loadedDesign.version) {
+                loadedDesign = Object.assign({ version: '1.0', background: '#ffffff', objects: [] }, loadedDesign);
+            }
+            // Validate objects array exists
+            if (!Array.isArray(loadedDesign.objects)) {
+                loadedDesign.objects = [];
+            }
+            const newProjectId = loadedDesign.projectId || 'default-project';
+            console.log('Setting projectId to:', newProjectId);
+            setProjectId(newProjectId);
+            console.log('Setting design state...');
+            setDesign(loadedDesign);
+            setFileHandle(handle);
+            // Load the design into the editor
+            // if (designEditorRef.current) {
+            //   console.log('Calling loadDesign on editor ref with:', loadedDesign);
+            //   designEditorRef.current.loadDesign(loadedDesign);
+            // } else {
+            //   console.warn('designEditorRef.current is null');
+            // }
+        }
+        catch (err) {
+            console.error('Error opening file:', err);
+            if (err instanceof Error) {
+                console.error('Error details:', {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack
+                });
+            }
+        }
+    };
+    const handleExport = () => {
+        const designData = JSON.stringify({ projectId }, null, 2);
+        const blob = new Blob([designData], { type: 'application/json' });
+        saveAs(blob, `${projectId}.json`);
+    };
+    return (React.createElement(Container, { fluid: true },
+        React.createElement(Row, { className: "mb-3" },
+            React.createElement(Col, null,
+                React.createElement("h1", null, "Design Editor"),
+                React.createElement("div", { className: "d-flex gap-2" },
+                    React.createElement(Button, { variant: "primary", onClick: handleOpen }, "Open"),
+                    React.createElement(Button, { variant: "success", onClick: handleSave }, "Save"),
+                    React.createElement(Button, { variant: "secondary", onClick: handleExport }, "Export")))),
+        React.createElement(Row, null,
+            React.createElement(Col, null))));
+};