testeranto 0.200.1 → 0.202.0

package/dist/module/src/services/FileService.js

@@ -0,0 +1,468 @@
+// Static Mode Service (Read-only)
+class StaticFileService {
+    async readFile(path) {
+        const response = await fetch(path);
+        if (!response.ok)
+            throw new Error(`Failed to read file: ${path}`);
+        return await response.text();
+    }
+    async readDirectory(path) {
+        // In static mode, we can't list directories from the client
+        // This would need to be provided by a server endpoint
+        return [];
+    }
+    async exists(path) {
+        try {
+            const response = await fetch(path, { method: "HEAD" });
+            return response.ok;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    // Write operations are no-ops in static mode
+    async writeFile() {
+        /* no-op */
+    }
+    async createDirectory() {
+        /* no-op */
+    }
+    async deleteFile() {
+        /* no-op */
+    }
+    // Git operations are not available in static mode
+    async getFileStatus() {
+        return { status: "unchanged" };
+    }
+    async getChanges() {
+        return [];
+    }
+    async commitChanges() {
+        throw new Error("Commit not available in static mode");
+    }
+    async pushChanges() {
+        throw new Error("Push not available in static mode");
+    }
+    async pullChanges() {
+        throw new Error("Pull not available in static mode");
+    }
+    async getCurrentBranch() {
+        return "main";
+    }
+    async getRemoteStatus() {
+        return { ahead: 0, behind: 0 };
+    }
+}
+// Development Mode Service (Full filesystem access via server)
+class DevelopmentFileService {
+    constructor() {
+        this.ws = null;
+        this.changeCallbacks = [];
+        this.statusCallbacks = [];
+        this.branchCallbacks = [];
+        this.connectWebSocket();
+    }
+    connectWebSocket() {
+        try {
+            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+            const wsUrl = `${protocol}//${window.location.host}/api/git-ws`;
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = () => {
+                var _a;
+                console.log('Git WebSocket connected');
+                // Request initial state
+                (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({ type: 'get-initial-state' }));
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    switch (data.type) {
+                        case 'changes':
+                            this.changeCallbacks.forEach(callback => callback(data.changes));
+                            break;
+                        case 'status':
+                            this.statusCallbacks.forEach(callback => callback(data.status));
+                            break;
+                        case 'branch':
+                            this.branchCallbacks.forEach(callback => callback(data.branch));
+                            break;
+                        case 'error':
+                            console.error('Git WebSocket error:', data.message);
+                            break;
+                    }
+                }
+                catch (error) {
+                    console.error('Error parsing WebSocket message:', error);
+                }
+            };
+            this.ws.onclose = () => {
+                console.log('Git WebSocket disconnected, attempting to reconnect...');
+                setTimeout(() => this.connectWebSocket(), 3000);
+            };
+            this.ws.onerror = (error) => {
+                console.error('Git WebSocket error:', error);
+            };
+        }
+        catch (error) {
+            console.error('Failed to connect Git WebSocket:', error);
+        }
+    }
+    // Subscribe to real-time changes
+    onChanges(callback) {
+        this.changeCallbacks.push(callback);
+        return () => {
+            this.changeCallbacks = this.changeCallbacks.filter(cb => cb !== callback);
+        };
+    }
+    onStatusUpdate(callback) {
+        this.statusCallbacks.push(callback);
+        return () => {
+            this.statusCallbacks = this.statusCallbacks.filter(cb => cb !== callback);
+        };
+    }
+    onBranchUpdate(callback) {
+        this.branchCallbacks.push(callback);
+        return () => {
+            this.branchCallbacks = this.branchCallbacks.filter(cb => cb !== callback);
+        };
+    }
+    async readFile(path) {
+        const response = await fetch(`/api/files/read?path=${encodeURIComponent(path)}`);
+        if (!response.ok)
+            throw new Error(`Failed to read file: ${path}`);
+        return await response.text();
+    }
+    async readDirectory(path) {
+        const response = await fetch(`/api/files/list?path=${encodeURIComponent(path)}`);
+        if (!response.ok)
+            throw new Error(`Failed to list directory: ${path}`);
+        return await response.json();
+    }
+    async exists(path) {
+        const response = await fetch(`/api/files/exists?path=${encodeURIComponent(path)}`);
+        return response.ok;
+    }
+    async writeFile(path, content) {
+        var _a;
+        const response = await fetch("/api/files/write", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path, content }),
+        });
+        if (!response.ok)
+            throw new Error(`Failed to write file: ${path}`);
+        // Notify server to update git status
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({ type: 'file-changed', path }));
+    }
+    async createDirectory(path) {
+        var _a;
+        const response = await fetch("/api/files/mkdir", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path }),
+        });
+        if (!response.ok)
+            throw new Error(`Failed to create directory: ${path}`);
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({ type: 'file-changed', path }));
+    }
+    async deleteFile(path) {
+        var _a;
+        const response = await fetch("/api/files/delete", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path }),
+        });
+        if (!response.ok)
+            throw new Error(`Failed to delete file: ${path}`);
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({ type: 'file-changed', path }));
+    }
+    async getFileStatus(path) {
+        const response = await fetch(`/api/git/status?path=${encodeURIComponent(path)}`);
+        if (!response.ok)
+            return { status: "unchanged" };
+        return await response.json();
+    }
+    async getChanges() {
+        const response = await fetch("/api/git/changes");
+        if (!response.ok)
+            return [];
+        return await response.json();
+    }
+    async commitChanges(message, description) {
+        var _a;
+        const response = await fetch("/api/git/commit", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ message, description }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to commit changes: ${error}`);
+        }
+        // Request updated status after commit
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({ type: 'refresh-status' }));
+    }
+    async pushChanges() {
+        var _a;
+        const response = await fetch("/api/git/push", {
+            method: "POST",
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to push changes: ${error}`);
+        }
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({ type: 'refresh-status' }));
+    }
+    async pullChanges() {
+        var _a;
+        const response = await fetch("/api/git/pull", {
+            method: "POST",
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to pull changes: ${error}`);
+        }
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({ type: 'refresh-status' }));
+    }
+    async getCurrentBranch() {
+        const response = await fetch("/api/git/branch");
+        if (!response.ok)
+            return "main";
+        return await response.text();
+    }
+    async getRemoteStatus() {
+        const response = await fetch("/api/git/remote-status");
+        if (!response.ok)
+            return { ahead: 0, behind: 0 };
+        return await response.json();
+    }
+}
+// Git Mode Service (isomorphic-git based)
+class GitFileService {
+    constructor() {
+        this.git = null;
+        this.fs = null;
+        this.dir = '/testeranto-git';
+    }
+    async ensureGit() {
+        if (!this.git) {
+            this.git = await import("isomorphic-git");
+            this.fs = await import("isomorphic-git/http/web");
+        }
+    }
+    async ensureBufferPolyfill() {
+        if (typeof window !== 'undefined' && !window.Buffer) {
+            const buffer = await import('buffer');
+            window.Buffer = buffer.Buffer;
+        }
+    }
+    async readFile(path) {
+        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) {
+        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 };
+        }
+    }
+}
+// Factory function to get the appropriate FileService based on mode
+export const getFileService = (mode) => {
+    switch (mode) {
+        case "static":
+            return new StaticFileService();
+        case "dev":
+            return new DevelopmentFileService();
+        case "git":
+            return new GitFileService();
+        default:
+            return new StaticFileService();
+    }
+};

package/dist/module/src/services/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();