@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/controllers/github-controller.js

@@ -0,0 +1,494 @@
+import { GitHubStateBag } from "../components/the-doctor/the-doctor";
+import { GitHubService } from "../services/github-service";
+import { ToastType } from "../model/toast";
+import { GitHubInstallationsLoaded, GitHubRepositoriesLoaded, GitHubRepositoryClaimed, GitHubRepositoryAttached, GitHubClaimRepository, GitHubAttachRepository, GitHubRefreshInstallations, GitHubRefreshRepositories, GitHubRepositoriesAsync, GitHubInstallationsAsync, ImportedRepoFileHoverOver, ImportedRepoFileHoverOut, LinkedWorkspaceHoverOver, LinkedWorkspaceHoverOut, GitHubCacheLoaded } from "../events/doctor";
+export class GitHubController extends EventTarget {
+    constructor(deps, globalTaskController, workspaceController) {
+        super();
+        this.installations = [];
+        this.repositories = [];
+        this.loadingInstallations = false;
+        this.loadingRepositories = false;
+        this.initialized = false;
+        this.deps = deps;
+        this.globalTaskController = globalTaskController;
+        this.workspaceController = workspaceController;
+        this.setupEventListeners();
+    }
+    setupEventListeners() {
+        this.addEventListener(GitHubClaimRepository, (event) => {
+            const installationId = event.detail;
+            this.claimRepository(installationId);
+        });
+        this.addEventListener(GitHubAttachRepository, (event) => {
+            const data = event.detail;
+            this.attachRepository(data.repositoryId, data.branch, data.filePath);
+        });
+        this.addEventListener(GitHubRefreshInstallations, () => {
+            this.loadInstallations();
+        });
+        this.addEventListener(GitHubRefreshRepositories, () => {
+            this.loadRepositories(true);
+        });
+        this.addEventListener(ImportedRepoFileHoverOver, (event) => {
+            const workspaceId = event.detail;
+            this.workspaceController.highlightWorkspace(workspaceId);
+        });
+        this.addEventListener(ImportedRepoFileHoverOut, (event) => {
+            const workspaceId = event.detail;
+            this.workspaceController.unhighlightWorkspace(workspaceId);
+        });
+        this.addEventListener(LinkedWorkspaceHoverOver, (event) => {
+            const data = event.detail;
+            this.highlightLinkedRepository(data.repositoryId, data.workspaceName);
+        });
+        this.addEventListener(LinkedWorkspaceHoverOut, (event) => {
+            const data = event.detail;
+            this.unhighlightLinkedRepository(data.repositoryId, data.workspaceName);
+        });
+    }
+    initFromCache() {
+        const bag = this.deps.githubStateBag;
+        if (!bag)
+            return false;
+        const cachedState = bag.get(GitHubStateBag);
+        if (!cachedState)
+            return false;
+        try {
+            this.installations = cachedState.installations || [];
+            this.repositories = cachedState.repositories || [];
+            this.installationsLastRefreshed = cachedState.installationsLastRefreshed;
+            this.repositoriesLastRefreshed = cachedState.repositoriesLastRefreshed;
+            this.lastError = cachedState.lastError;
+            this.dispatchEvent(new CustomEvent(GitHubCacheLoaded, {
+                bubbles: true,
+                composed: true,
+                detail: {
+                    installations: this.installations,
+                    repositories: this.repositories,
+                    installationsLastRefreshed: this.installationsLastRefreshed,
+                    repositoriesLastRefreshed: this.repositoriesLastRefreshed
+                }
+            }));
+            if (this.installations.length > 0) {
+                this.dispatchEvent(new CustomEvent(GitHubInstallationsLoaded, {
+                    bubbles: true,
+                    composed: true,
+                    detail: this.installations
+                }));
+            }
+            if (this.repositories.length > 0) {
+                this.dispatchEvent(new CustomEvent(GitHubRepositoriesLoaded, {
+                    bubbles: true,
+                    composed: true,
+                    detail: this.repositories
+                }));
+            }
+            return this.installations.length > 0;
+        }
+        catch (e) {
+            console.warn('[GitHubController] Failed to load from cache:', e);
+            return false;
+        }
+    }
+    saveToCache() {
+        const bag = this.deps.githubStateBag;
+        if (!bag)
+            return;
+        const state = {
+            installations: this.installations,
+            repositories: this.repositories,
+            installationsLastRefreshed: this.installationsLastRefreshed,
+            repositoriesLastRefreshed: this.repositoriesLastRefreshed,
+            lastError: this.lastError
+        };
+        bag.set(GitHubStateBag, state);
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        const hadCachedInstallations = this.initFromCache();
+        if (!hadCachedInstallations) {
+            await this.loadInstallations();
+        }
+    }
+    async loadInstallations() {
+        if (this.loadingInstallations)
+            return;
+        this.loadingInstallations = true;
+        try {
+            const brokerId = this.deps.getBrokerId();
+            const response = await GitHubService.getInstallations(brokerId);
+            // Check HTTP status to determine if operation is in progress (202) or complete (200)
+            const httpStatus = response.httpStatus;
+            if (httpStatus === 202) {
+                // 202 Accepted - async operation in progress
+                // Dispatch async event so UI knows operation is running
+                this.dispatchEvent(new CustomEvent(GitHubInstallationsAsync, {
+                    bubbles: true,
+                    composed: true
+                }));
+                return;
+            }
+            // 200 OK or no status (backward compatibility) - data is ready
+            if (response.response) {
+                // The response.response is directly the array
+                if (Array.isArray(response.response)) {
+                    this.installations = response.response;
+                }
+                else {
+                    this.installations = [];
+                }
+                this.installationsLastRefreshed = new Date().toISOString();
+                this.lastError = undefined;
+                this.saveToCache();
+                this.dispatchEvent(new CustomEvent(GitHubInstallationsLoaded, {
+                    bubbles: true,
+                    composed: true,
+                    detail: this.installations
+                }));
+            }
+        }
+        catch (error) {
+            console.error('Failed to load GitHub installations:', error);
+            const apiError = error;
+            this.lastError = {
+                message: apiError.detail || 'An error occurred while loading GitHub installations',
+                timestamp: new Date().toISOString()
+            };
+            this.saveToCache();
+            if (apiError.status !== 404) {
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    title: 'Failed to load GitHub installations',
+                    body: apiError.detail || 'An error occurred while loading GitHub installations'
+                });
+            }
+        }
+        finally {
+            this.loadingInstallations = false;
+        }
+    }
+    waitForScanCompletion(_jobId) {
+        if (!this.globalTaskController) {
+            console.error('[GitHubController] GlobalTaskController is not initialized!');
+            return;
+        }
+        this.loadRepositoriesAfterScan();
+    }
+    async loadRepositoriesAfterScan() {
+        // Clear any existing polling interval
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+        }
+        // Start polling for repository data
+        this.pollingInterval = window.setInterval(async () => {
+            try {
+                const brokerId = this.deps.getBrokerId();
+                const response = await GitHubService.getRepositories(brokerId);
+                // Check if we got repository data
+                if (response.response && Array.isArray(response.response)) {
+                    // Success! Clear the interval and process the data
+                    clearInterval(this.pollingInterval);
+                    this.pollingInterval = undefined;
+                    this.repositories = response.response;
+                    this.repositoriesLastRefreshed = new Date().toISOString();
+                    this.lastError = undefined;
+                    this.saveToCache();
+                    this.dispatchEvent(new CustomEvent(GitHubRepositoriesLoaded, {
+                        bubbles: true,
+                        composed: true,
+                        detail: this.repositories
+                    }));
+                    // Show success toast
+                    this.deps.sendToast({
+                        id: crypto.randomUUID(),
+                        type: ToastType.SUCCESS,
+                        title: 'Repositories loaded',
+                        body: `Found ${this.repositories.length} repositories available to the doctor.`
+                    });
+                }
+                else if (response.jobId || response.jobID) {
+                    // Still scanning, continue polling
+                }
+                else {
+                    // No repositories found, stop polling, cancel the timer
+                    clearInterval(this.pollingInterval);
+                    this.pollingInterval = undefined;
+                    this.dispatchEvent(new CustomEvent(GitHubRepositoriesLoaded, {
+                        bubbles: true,
+                        composed: true,
+                        detail: this.repositories
+                    }));
+                }
+            }
+            catch (error) {
+                console.error('[GitHubController] Error polling for repositories:', error);
+                // Stop polling on error
+                clearInterval(this.pollingInterval);
+                this.pollingInterval = undefined;
+            }
+        }, 1000); // Poll every second if required.
+    }
+    async loadRepositories(refresh = false) {
+        if (this.loadingRepositories)
+            return;
+        this.loadingRepositories = true;
+        try {
+            const brokerId = this.deps.getBrokerId();
+            const response = await GitHubService.getRepositories(brokerId, refresh);
+            // Check HTTP status to determine if operation is in progress (202) or complete (200)
+            const httpStatus = response.httpStatus;
+            if (httpStatus === 202) {
+                // 202 Accepted - async operation in progress
+                // Check if it's a scan job response
+                if (response.jobId || response.jobID) {
+                    const jobId = response.jobId || response.jobID;
+                    // Show toast about scanning
+                    this.deps.sendToast({
+                        id: crypto.randomUUID(),
+                        type: ToastType.INFO,
+                        title: 'Scanning repositories',
+                        body: 'Scanning your GitHub repositories...'
+                    });
+                    // Dispatch async event so UI knows operation is running
+                    this.dispatchEvent(new CustomEvent(GitHubRepositoriesAsync, {
+                        bubbles: true,
+                        composed: true
+                    }));
+                    // Register callback for when scan completes
+                    this.waitForScanCompletion(jobId);
+                }
+                else {
+                    // 202 but no job ID - still async
+                    this.dispatchEvent(new CustomEvent(GitHubRepositoriesAsync, {
+                        bubbles: true,
+                        composed: true
+                    }));
+                }
+            }
+            else if (httpStatus === 200 || !httpStatus) {
+                // 200 OK - data is ready (or old code path for backward compatibility)
+                if (response.response) {
+                    // Check if response.response contains the data
+                    const responseData = response.response;
+                    if (Array.isArray(responseData)) {
+                        // Direct array of repositories
+                        this.repositories = responseData;
+                    }
+                    else {
+                        // Single repository or empty
+                        this.repositories = [];
+                    }
+                }
+                else {
+                    // No repositories found
+                    this.repositories = [];
+                }
+                this.repositoriesLastRefreshed = new Date().toISOString();
+                this.lastError = undefined;
+                this.saveToCache();
+                // Data is ready, dispatch event to stop loader
+                this.dispatchEvent(new CustomEvent(GitHubRepositoriesLoaded, {
+                    bubbles: true,
+                    composed: true,
+                    detail: this.repositories
+                }));
+            }
+        }
+        catch (error) {
+            console.error('Failed to load GitHub repositories:', error);
+            const apiError = error;
+            this.lastError = {
+                message: apiError.detail || 'An error occurred while loading GitHub repositories',
+                timestamp: new Date().toISOString()
+            };
+            this.saveToCache();
+            if (apiError.status !== 404) {
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    title: 'Failed to load GitHub repositories',
+                    body: apiError.detail || 'An error occurred while loading GitHub repositories'
+                });
+            }
+        }
+        finally {
+            this.loadingRepositories = false;
+        }
+    }
+    async claimRepository(installationId) {
+        try {
+            const brokerId = this.deps.getBrokerId();
+            const response = await GitHubService.claimRepository(installationId, brokerId);
+            if (response.success) {
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.SUCCESS,
+                    title: 'Repository claim initiated',
+                    body: response.message || 'Processing repository claim...'
+                });
+                if (response.taskId) {
+                    const task = await this.globalTaskController.waitForTask(response.taskId);
+                    if (task.status === 'completed') {
+                        this.deps.sendToast({
+                            id: crypto.randomUUID(),
+                            type: ToastType.SUCCESS,
+                            title: 'Repository claimed',
+                            body: 'Repository has been successfully claimed'
+                        });
+                        await this.loadRepositories();
+                        await this.loadInstallations();
+                        this.dispatchEvent(new CustomEvent(GitHubRepositoryClaimed, {
+                            bubbles: true,
+                            composed: true,
+                            detail: installationId
+                        }));
+                    }
+                    else if (task.status === 'failed') {
+                        this.deps.sendToast({
+                            id: crypto.randomUUID(),
+                            type: ToastType.ERROR,
+                            title: 'Repository claim failed',
+                            body: task.error || 'Failed to claim repository'
+                        });
+                    }
+                }
+            }
+            else {
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    title: 'Repository claim failed',
+                    body: response.message || 'Failed to claim repository'
+                });
+            }
+        }
+        catch (error) {
+            console.error('Failed to claim repository:', error);
+            const apiError = error;
+            this.deps.sendToast({
+                id: crypto.randomUUID(),
+                type: ToastType.ERROR,
+                title: 'Repository claim failed',
+                body: apiError.detail || 'An error occurred while claiming repository'
+            });
+        }
+    }
+    async attachRepository(repositoryId, branch, filePath) {
+        try {
+            const brokerId = this.deps.getBrokerId();
+            const response = await GitHubService.attachRepository(repositoryId, branch, filePath, brokerId);
+            // Check if a task was started (even if success is false)
+            if (response.taskId) {
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.INFO,
+                    title: 'Repository import initiated',
+                    body: response.message || 'Importing repository into workspace...'
+                });
+                const task = await this.globalTaskController.waitForTask(response.taskId);
+                if (task.status === 'completed') {
+                    // Refresh workspaces and repositories to get updated data
+                    await this.workspaceController.refreshWorkspaces();
+                    //await this.loadRepositories();
+                    this.deps.reboot();
+                    this.deps.sendToast({
+                        id: crypto.randomUUID(),
+                        type: ToastType.SUCCESS,
+                        title: 'Repository imported successfully',
+                        body: 'Repository has been imported and workspace has been updated'
+                    });
+                    const workspaceId = response.workspaceId || task.workspaceId;
+                    if (workspaceId) {
+                        await this.workspaceController.switchToWorkspaceById(workspaceId);
+                    }
+                    this.dispatchEvent(new CustomEvent(GitHubRepositoryAttached, {
+                        bubbles: true,
+                        composed: true,
+                        detail: {
+                            repositoryId,
+                            workspaceId: workspaceId
+                        }
+                    }));
+                }
+                else if (task.status === 'failed') {
+                    this.deps.sendToast({
+                        id: crypto.randomUUID(),
+                        type: ToastType.ERROR,
+                        title: 'Repository import failed',
+                        body: task.error || 'Failed to import repository'
+                    });
+                }
+            }
+            else {
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    title: 'Repository import failed',
+                    body: response.message || 'Failed to import repository'
+                });
+            }
+        }
+        catch (error) {
+            console.error('Failed to attach repository:', error);
+            const apiError = error;
+            this.deps.sendToast({
+                id: crypto.randomUUID(),
+                type: ToastType.ERROR,
+                title: 'Repository import failed',
+                body: apiError.detail || 'An error occurred while importing repository'
+            });
+        }
+    }
+    getInstallations() {
+        return this.installations;
+    }
+    getRepositories() {
+        return this.repositories;
+    }
+    getInstallationsLastRefreshed() {
+        return this.installationsLastRefreshed;
+    }
+    getRepositoriesLastRefreshed() {
+        return this.repositoriesLastRefreshed;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+    isLoadingInstallations() {
+        return this.loadingInstallations;
+    }
+    isLoadingRepositories() {
+        return this.loadingRepositories;
+    }
+    setGitHubView(view) {
+        this.githubView = view;
+    }
+    highlightLinkedRepository(repositoryId, workspaceName) {
+        if (this.githubView) {
+            this.githubView.highlightRepository(repositoryId, workspaceName);
+        }
+    }
+    unhighlightLinkedRepository(repositoryId, workspaceName) {
+        if (this.githubView) {
+            this.githubView.unhighlightRepository(repositoryId, workspaceName);
+        }
+    }
+    cleanup() {
+        // Clear polling interval if it's still running
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+        }
+    }
+    destroy() {
+        this.cleanup();
+    }
+    reinitialize() {
+        this.initialized = false;
+        this.init();
+    }
+}

package/dist/controllers/global-task-controller.d.ts

@@ -0,0 +1,46 @@
+import { Task, TaskAction } from "../model/task.js";
+import { GlobalTaskView } from "../components/global-task/global-task-view.js";
+import { TerminalMessage } from "../components/terminal-emulator/terminal-emulator.js";
+import type { GlobalTaskControllerDeps } from "../interfaces/doctor-interfaces.js";
+export declare class GlobalTaskController extends EventTarget {
+    private readonly deps;
+    private readonly bus;
+    private taskStreamChannel;
+    private taskStreamSubscription;
+    private tasks;
+    private view;
+    private consoleMessages;
+    private mockMode;
+    private mockGenerator;
+    private taskCallbacks;
+    private typeSubscriptions;
+    private pendingTimeouts;
+    constructor(deps: GlobalTaskControllerDeps);
+    setView(view: GlobalTaskView): void;
+    init(): void;
+    enableMockMode(): void;
+    disableMockMode(): void;
+    private loadInitialTasks;
+    private taskStreamHandler;
+    private handleTaskMessage;
+    private processTask;
+    private addTask;
+    private updateTask;
+    private completeTask;
+    private failTask;
+    private removeTask;
+    private addConsoleMessage;
+    private updateView;
+    private calculateOverallProgress;
+    private formatDuration;
+    getActiveTasks(): Task[];
+    getAllTasks(): Task[];
+    getConsoleMessages(): TerminalMessage[];
+    registerTaskCallback(taskId: string, callback: (task: Task) => void): void;
+    unregisterTaskCallback(taskId: string, callback?: (task: Task) => void): void;
+    private triggerTaskCallbacks;
+    waitForTask(taskId: string): Promise<Task>;
+    subscribeToTaskType(taskType: string, callback: (task: Task) => void, actions?: TaskAction[]): () => void;
+    private notifyTypeSubscribers;
+    destroy(): void;
+}