mycoder-agent/dist/tools/session/SessionTracker.js

Agent module for mycoder - an AI-powered software development assistant

import { v4 as uuidv4 } from 'uuid';
import { browserSessions } from './lib/types.js';
// Status of a browser session
export var SessionStatus;
(function (SessionStatus) {
    SessionStatus["RUNNING"] = "running";
    SessionStatus["COMPLETED"] = "completed";
    SessionStatus["ERROR"] = "error";
    SessionStatus["TERMINATED"] = "terminated";
})(SessionStatus || (SessionStatus = {}));
/**
 * Registry to keep track of browser sessions
 */
export class SessionTracker {
    ownerAgentId;
    sessions = new Map();
    constructor(ownerAgentId) {
        this.ownerAgentId = ownerAgentId;
    }
    // Register a new browser session
    registerBrowser(url) {
        const id = uuidv4();
        const session = {
            id,
            status: SessionStatus.RUNNING,
            startTime: new Date(),
            metadata: {
                url,
            },
        };
        this.sessions.set(id, session);
        return id;
    }
    // Update the status of a browser session
    updateSessionStatus(id, status, metadata) {
        const session = this.sessions.get(id);
        if (!session) {
            return false;
        }
        session.status = status;
        if (status === SessionStatus.COMPLETED ||
            status === SessionStatus.ERROR ||
            status === SessionStatus.TERMINATED) {
            session.endTime = new Date();
        }
        if (metadata) {
            session.metadata = { ...session.metadata, ...metadata };
        }
        return true;
    }
    // Get all browser sessions
    getSessions() {
        return Array.from(this.sessions.values());
    }
    // Get a specific browser session by ID
    getSessionById(id) {
        return this.sessions.get(id);
    }
    // Filter sessions by status
    getSessionsByStatus(status) {
        return this.getSessions().filter((session) => session.status === status);
    }
    /**
     * Cleans up all browser sessions associated with this tracker
     * @returns A promise that resolves when cleanup is complete
     */
    async cleanup() {
        const sessions = this.getSessionsByStatus(SessionStatus.RUNNING);
        // Create cleanup promises for each session
        const cleanupPromises = sessions.map((session) => this.cleanupSession(session));
        // Wait for all cleanup operations to complete in parallel
        await Promise.all(cleanupPromises);
    }
    /**
     * Cleans up a browser session
     * @param session The browser session to clean up
     */
    async cleanupSession(session) {
        try {
            const browserManager = globalThis.__BROWSER_MANAGER__;
            if (browserManager) {
                await browserManager.closeSession(session.id);
            }
            else {
                // Fallback to closing via browserSessions if SessionManager is not available
                const browserSession = browserSessions.get(session.id);
                if (browserSession) {
                    await browserSession.page.context().close();
                    await browserSession.browser.close();
                    browserSessions.delete(session.id);
                }
            }
            this.updateSessionStatus(session.id, SessionStatus.COMPLETED);
        }
        catch (error) {
            this.updateSessionStatus(session.id, SessionStatus.ERROR, {
                error: error instanceof Error ? error.message : String(error),
            });
        }
    }
}
//# sourceMappingURL=SessionTracker.js.map