testeranto 0.202.0 → 0.203.0

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

@@ -1,468 +0,0 @@
-// 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

@@ -1,180 +0,0 @@
-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();