@perfai/mcp 1.0.24

package/dist/auth/authManager.js

@@ -0,0 +1,555 @@
+import axios from "axios";
+import open from "open";
+import { createHash, randomBytes } from "crypto";
+import * as http from "http";
+import { URL } from "url";
+import { AUTH0_DOMAIN, CLIENT_ID, CLIENT_SECRET, REDIRECT_URI, API_ENDPOINTS } from '../config.js';
+import { SessionStorage } from './sessionStorage.js';
+export class AuthenticationManager {
+    session = null;
+    codeVerifier = "";
+    authServer = null;
+    sessionStorage;
+    isInitialized = false;
+    initializationPromise;
+    constructor() {
+        this.sessionStorage = new SessionStorage();
+        this.initializationPromise = this.initializeSession();
+    }
+    /**
+     * Wait for session initialization to complete
+     */
+    async waitForInitialization() {
+        if (!this.isInitialized) {
+            await this.initializationPromise;
+        }
+    }
+    /**
+     * Initialize session from persistent storage
+     */
+    async initializeSession() {
+        if (this.isInitialized)
+            return;
+        try {
+            console.error('🔍 Checking for saved session...');
+            const savedSession = await this.sessionStorage.loadSession();
+            if (savedSession) {
+                this.session = savedSession;
+                const userEmail = savedSession.userInfo?.email || 'Unknown';
+                const timeLeft = Math.round((savedSession.expiresAt - Date.now()) / (1000 * 60 * 60));
+                console.error(`✅ Session restored for ${userEmail}, expires in ${timeLeft} hours`);
+                // Auto-save session updates
+                this.scheduleSessionSave();
+            }
+            else {
+                console.error('📝 No valid saved session found');
+            }
+        }
+        catch (error) {
+            console.error('⚠️  Failed to initialize session:', error);
+        }
+        finally {
+            this.isInitialized = true;
+        }
+    }
+    /**
+     * Schedule automatic session saving when session data changes
+     */
+    scheduleSessionSave() {
+        if (this.session) {
+            // Debounced save to avoid excessive I/O
+            setTimeout(() => {
+                if (this.session) {
+                    this.sessionStorage.saveSession(this.session);
+                }
+            }, 1000);
+        }
+    }
+    async isAuthenticated() {
+        // Ensure session is initialized
+        if (!this.isInitialized) {
+            await this.initializationPromise;
+        }
+        if (!this.session)
+            return false;
+        const isValid = Date.now() < this.session.expiresAt;
+        // If session is expired, clear it
+        if (!isValid && this.session) {
+            console.error('⏰ Session expired, clearing storage');
+            this.clearSession();
+        }
+        return isValid;
+    }
+    /**
+     * Synchronous version for backward compatibility
+     * Note: This will return false if initialization is still in progress
+     */
+    isAuthenticatedSync() {
+        if (!this.isInitialized || !this.session)
+            return false;
+        const isValid = Date.now() < this.session.expiresAt;
+        // If session is expired, clear it
+        if (!isValid && this.session) {
+            console.error('⏰ Session expired, clearing storage');
+            this.clearSession();
+        }
+        return isValid;
+    }
+    getUserInfo() {
+        return this.session?.userInfo || null;
+    }
+    getAccessToken() {
+        return this.session?.accessToken || null;
+    }
+    getTokenType() {
+        return this.session?.tokenType || 'Bearer';
+    }
+    getSelectedOrgId() {
+        return this.session?.selectedOrgId || null;
+    }
+    getOrganizations() {
+        return this.session?.organizations || [];
+    }
+    setSelectedOrgId(orgId) {
+        if (this.session) {
+            this.session.selectedOrgId = orgId;
+            this.scheduleSessionSave();
+        }
+    }
+    // APP management methods
+    getSelectedApiId() {
+        return this.session?.selectedApiId || null;
+    }
+    getSelectedApiData() {
+        return this.session?.selectedApiData || null;
+    }
+    getSelectedApiIdentifier() {
+        return this.session?.selectedApiIdentifier || null;
+    }
+    setSelectedApi(apiId, apiData, apiIdentifier) {
+        if (this.session) {
+            this.session.selectedApiId = apiId;
+            this.session.selectedApiData = apiData;
+            this.session.selectedApiIdentifier = apiIdentifier;
+            this.scheduleSessionSave();
+        }
+    }
+    // Security app ID management methods
+    getSelectedSecurityAppId() {
+        return this.session?.selectedSecurityAppId || null;
+    }
+    setSelectedSecurityAppId(securityAppId) {
+        if (this.session) {
+            this.session.selectedSecurityAppId = securityAppId;
+            this.scheduleSessionSave();
+        }
+    }
+    // Design app ID management methods
+    getSelectedDesignAppId() {
+        return this.session?.selectedDesignAppId || null;
+    }
+    setSelectedDesignAppId(designAppId) {
+        if (this.session) {
+            this.session.selectedDesignAppId = designAppId;
+            this.scheduleSessionSave();
+        }
+    }
+    // Quality app ID management methods
+    getSelectedQualityAppId() {
+        return this.session?.selectedQualityAppId || null;
+    }
+    setSelectedQualityAppId(qualityAppId) {
+        if (this.session) {
+            this.session.selectedQualityAppId = qualityAppId;
+            this.scheduleSessionSave();
+        }
+    }
+    // App sequence mapping methods
+    setAppSequenceMap(sequenceMap) {
+        if (this.session) {
+            this.session.appSequenceMap = sequenceMap;
+            this.scheduleSessionSave();
+        }
+    }
+    getAppSequenceMap() {
+        return this.session?.appSequenceMap || null;
+    }
+    getAppIdBySequence(sequenceNumber) {
+        const sequenceMap = this.getAppSequenceMap();
+        return sequenceMap?.get(sequenceNumber) || null;
+    }
+    clearAppSequenceMap() {
+        if (this.session) {
+            this.session.appSequenceMap = undefined;
+            this.scheduleSessionSave();
+        }
+    }
+    // Fixed issues management methods
+    getFixedIssues() {
+        return this.session?.fixedIssues || [];
+    }
+    markIssueAsFixed(issueId, issue, prompt) {
+        if (!this.session) {
+            throw new Error('No active session');
+        }
+        const fixedIssue = {
+            issueId,
+            issue: {
+                ...issue,
+                isAIFixed: true,
+                aiFixedAt: new Date(),
+                aiFixPrompt: prompt,
+            },
+            fixedAt: new Date(),
+            prompt,
+            status: "ai-fixed",
+        };
+        // Initialize fixedIssues array if it doesn't exist
+        if (!this.session.fixedIssues) {
+            this.session.fixedIssues = [];
+        }
+        // Add or update fixed issue
+        const existingIndex = this.session.fixedIssues.findIndex((fi) => fi.issueId === issueId);
+        if (existingIndex !== -1) {
+            this.session.fixedIssues[existingIndex] = fixedIssue;
+        }
+        else {
+            this.session.fixedIssues.push(fixedIssue);
+        }
+        this.scheduleSessionSave();
+        return fixedIssue;
+    }
+    isIssueFixed(issueId) {
+        return this.session?.fixedIssues?.some(fi => fi.issueId === issueId) || false;
+    }
+    clearFixedIssues() {
+        if (this.session) {
+            this.session.fixedIssues = [];
+            this.scheduleSessionSave();
+            console.error('🗑️  Fixed issues cleared from session');
+        }
+    }
+    // Design fixed issues management methods
+    getFixedDesignIssues() {
+        return this.session?.fixedDesignIssues || [];
+    }
+    markDesignIssueAsFixed(issueId, issue, prompt) {
+        if (!this.session) {
+            throw new Error('No active session');
+        }
+        const fixedIssue = {
+            issueId,
+            issue: {
+                ...issue,
+                isAIFixed: true,
+                aiFixedAt: new Date(),
+                aiFixPrompt: prompt
+            },
+            fixedAt: new Date(),
+            prompt,
+            status: 'ai-fixed'
+        };
+        // Initialize fixedDesignIssues array if it doesn't exist
+        if (!this.session.fixedDesignIssues) {
+            this.session.fixedDesignIssues = [];
+        }
+        // Check if issue is already fixed and update or add
+        const existingIndex = this.session.fixedDesignIssues.findIndex(fi => fi.issueId === issueId);
+        if (existingIndex !== -1) {
+            this.session.fixedDesignIssues[existingIndex] = fixedIssue;
+            console.error(`🔄 Updated existing design fix for issue: ${issueId}`);
+        }
+        else {
+            this.session.fixedDesignIssues.push(fixedIssue);
+            console.error(`✅ Design issue marked as fixed: ${issueId}`);
+        }
+        this.scheduleSessionSave();
+        return fixedIssue;
+    }
+    isDesignIssueFixed(issueId) {
+        return this.session?.fixedDesignIssues?.some(fi => fi.issueId === issueId) || false;
+    }
+    clearFixedDesignIssues() {
+        if (this.session) {
+            this.session.fixedDesignIssues = [];
+            this.scheduleSessionSave();
+            console.error('🗑️  Fixed design issues cleared from session');
+        }
+    }
+    // Quality fixed issues management methods
+    getFixedQualityIssues() {
+        return this.session?.fixedQualityIssues || [];
+    }
+    addFixedQualityIssue(fixedIssue) {
+        if (!this.session) {
+            throw new Error('No active session');
+        }
+        // Initialize fixedQualityIssues array if it doesn't exist
+        if (!this.session.fixedQualityIssues) {
+            this.session.fixedQualityIssues = [];
+        }
+        // Add or update fixed issue
+        const existingIndex = this.session.fixedQualityIssues.findIndex(fi => fi.issueId === fixedIssue.issueId);
+        if (existingIndex !== -1) {
+            this.session.fixedQualityIssues[existingIndex] = fixedIssue;
+            console.error(`🔄 Updated existing quality fix for issue: ${fixedIssue.issueId}`);
+        }
+        else {
+            this.session.fixedQualityIssues.push(fixedIssue);
+            console.error(`✅ Quality issue marked as fixed: ${fixedIssue.issueId}`);
+        }
+        this.scheduleSessionSave();
+    }
+    markQualityIssueAsFixed(issueId, issue, prompt) {
+        if (!this.session) {
+            throw new Error('No active session');
+        }
+        const fixedIssue = {
+            issueId,
+            issue: {
+                ...issue,
+                isAIFixed: true,
+                aiFixedAt: new Date(),
+                aiFixPrompt: prompt,
+            },
+            fixedAt: new Date(),
+            prompt,
+            status: "ai-fixed",
+        };
+        this.addFixedQualityIssue(fixedIssue);
+        return fixedIssue;
+    }
+    isQualityIssueFixed(issueId) {
+        return this.session?.fixedQualityIssues?.some(fi => fi.issueId === issueId) || false;
+    }
+    clearFixedQualityIssues() {
+        if (this.session) {
+            this.session.fixedQualityIssues = [];
+            this.scheduleSessionSave();
+            console.error('🗑️  Fixed quality issues cleared from session');
+        }
+    }
+    clearSession() {
+        this.session = null;
+        this.sessionStorage.clearSession();
+        console.error('🗑️  Session cleared from memory and storage');
+    }
+    /**
+     * Get session storage location for debugging
+     */
+    getStorageLocation() {
+        return this.sessionStorage.getStorageLocation();
+    }
+    /**
+     * Check if there's a valid session in storage without loading it
+     */
+    hasValidStoredSession() {
+        return this.sessionStorage.hasValidSession();
+    }
+    /**
+     * Save current session to persistent storage
+     */
+    async saveCurrentSession() {
+        if (this.session) {
+            await this.sessionStorage.saveSession(this.session);
+        }
+        else {
+            throw new Error('No active session to save');
+        }
+    }
+    generateCodeChallenge() {
+        this.codeVerifier = randomBytes(32).toString('base64url');
+        const codeChallenge = createHash('sha256')
+            .update(this.codeVerifier)
+            .digest('base64url');
+        return { codeVerifier: this.codeVerifier, codeChallenge };
+    }
+    buildAuthUrl() {
+        const { codeChallenge } = this.generateCodeChallenge();
+        const params = new URLSearchParams({
+            response_type: "code",
+            client_id: CLIENT_ID,
+            redirect_uri: REDIRECT_URI,
+            scope: "openid profile email offline_access",
+            //code_challenge: codeChallenge,
+            //code_challenge_method: "S256",
+        });
+        return `https://${AUTH0_DOMAIN}/authorize?${params.toString()}`;
+    }
+    async manualCodeFlow() {
+        const authUrl = this.buildAuthUrl();
+        // Open browser for user to authenticate
+        await open(authUrl);
+        return authUrl;
+    }
+    async startAuthServer() {
+        return new Promise((resolve, reject) => {
+            this.authServer = http.createServer(async (req, res) => {
+                if (req.url?.startsWith('/') || req.url?.startsWith('/auth-callback')) {
+                    try {
+                        const url = new URL(req.url, `http://localhost:5173`);
+                        const code = url.searchParams.get('code');
+                        const error = url.searchParams.get('error');
+                        if (error) {
+                            throw new Error(`Auth error: ${error}`);
+                        }
+                        if (!code) {
+                            throw new Error('No authorization code received');
+                        }
+                        // Exchange code for tokens
+                        await this.exchangeCodeForTokens(code);
+                        // Send success response
+                        res.writeHead(200, { 'Content-Type': 'text/html' });
+                        res.end(`
+              <html>
+                <body style="font-family: Arial, sans-serif; padding: 50px; text-align: center;">
+                  <h1 style="color: #28a745;">✅ Authentication Successful!</h1>
+                  <p>You have successfully logged in to PerfAI MCP Server.</p>
+                  <p>You can now close this window and return to your MCP client.</p>
+                  <script>setTimeout(() => window.close(), 3000);</script>
+                </body>
+              </html>
+            `);
+                        // Close server after successful auth
+                        setTimeout(() => {
+                            this.authServer?.close();
+                            this.authServer = null;
+                        }, 1000);
+                        resolve('Authentication successful');
+                    }
+                    catch (error) {
+                        res.writeHead(400, { 'Content-Type': 'text/html' });
+                        res.end(`
+              <html>
+                <body style="font-family: Arial, sans-serif; padding: 50px; text-align: center;">
+                  <h1 style="color: #dc3545;">❌ Authentication Failed</h1>
+                  <p>Error: ${error instanceof Error ? error.message : 'Unknown error'}</p>
+                  <p>Please try again.</p>
+                </body>
+              </html>
+            `);
+                        reject(error);
+                    }
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Not found');
+                }
+            });
+            // Try to bind to port 5173 first (matching Auth0 config), fallback to 5174
+            const tryPort = (port) => {
+                this.authServer.listen(port, () => {
+                    console.error(`🚀 Auth server listening on port ${port} for OAuth callback`);
+                    if (port === 5173) {
+                        console.error('✅ Using port 5173 - matches your Auth0 configuration perfectly!');
+                    }
+                    else {
+                        console.error('⚠️  Using port 5174 - Auth0 should redirect to localhost:5173/auth-callback');
+                        console.error('   (The server will handle the callback regardless of port)');
+                    }
+                    resolve('Authentication server started');
+                });
+                this.authServer.on('error', (error) => {
+                    if (error.code === 'EADDRINUSE' && port === 5173) {
+                        console.error('⚠️  Port 5173 is busy (MCP Inspector running), trying port 5174...');
+                        // Clear the error handler before trying the next port
+                        this.authServer.removeAllListeners('error');
+                        tryPort(5174);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            };
+            tryPort(5173);
+        });
+    }
+    async exchangeCodeForTokens(code) {
+        console.error('🔄 Starting token exchange process...');
+        const tokenData = {
+            grant_type: 'authorization_code',
+            client_id: CLIENT_ID,
+            client_secret: CLIENT_SECRET,
+            code: code,
+            redirect_uri: REDIRECT_URI,
+        };
+        try {
+            console.error('📡 Sending token request to Auth0...');
+            const response = await axios.post(API_ENDPOINTS.TOKEN, tokenData, {
+                headers: { 'Content-Type': 'application/json' }
+            });
+            console.error('✅ Token response received');
+            const { access_token, id_token, expires_in, token_type } = response.data;
+            console.error('🎫 Tokens extracted - access_token:', !!access_token, 'id_token:', !!id_token, 'expires_in:', expires_in, 'token_type:', token_type);
+            // Get user info
+            console.error('👤 Fetching user information...');
+            const userInfoResponse = await axios.get(API_ENDPOINTS.USERINFO, {
+                headers: { Authorization: `Bearer ${access_token}` }
+            });
+            console.error('✅ User info received:', userInfoResponse.data.email);
+            // Fetch user organizations
+            let organizations = [];
+            let selectedOrgId = undefined;
+            try {
+                console.error('🏢 Attempting to fetch organizations...');
+                const orgResponse = await axios.get(API_ENDPOINTS.ORGANIZATIONS, {
+                    headers: { Authorization: `Bearer ${access_token}` }
+                });
+                console.error('🏢 Organization response status:', orgResponse.status);
+                console.error('🏢 Organization response data:', JSON.stringify(orgResponse.data, null, 2));
+                organizations = orgResponse.data.data?.userOrgs || [];
+                const currentOrgId = orgResponse.data.data?.currentOrg;
+                // Prefer current org from APP; fallback to first available org_id
+                selectedOrgId = currentOrgId || organizations[0]?.org_id;
+                console.error(`📊 Found ${organizations.length} organizations, current: ${currentOrgId}`);
+                if (organizations.length === 0) {
+                    console.error('⚠️ No organizations found in response - this might cause issues with APP calls');
+                }
+                else {
+                    console.error(`🔍 First org structure:`, JSON.stringify(organizations[0], null, 2));
+                }
+            }
+            catch (orgError) {
+                console.error('⚠️ Failed to fetch organizations:');
+                console.error('   Error:', orgError instanceof Error ? orgError.message : String(orgError));
+                if (axios.isAxiosError(orgError)) {
+                    console.error('   Status:', orgError.response?.status);
+                    console.error('   Response:', JSON.stringify(orgError.response?.data, null, 2));
+                }
+                // Continue without organizations - user can still authenticate but won't be able to access org-specific data
+            }
+            // Store session
+            console.error('💾 Creating session object...');
+            this.session = {
+                // Align with extension behavior: prefer id_token for APP calls
+                accessToken: id_token || access_token,
+                idToken: id_token,
+                tokenType: token_type || 'Bearer',
+                userInfo: userInfoResponse.data,
+                expiresAt: Date.now() + (expires_in * 1000),
+                organizations,
+                selectedOrgId
+            };
+            console.error('✅ Session object created in memory');
+            // Save session to persistent storage - COMMENTED OUT FOR SECURITY
+            // console.error('💾 Attempting to save session to persistent storage...');
+            // try {
+            //   await this.sessionStorage.saveSession(this.session);
+            //   console.error('✅ Session saved successfully to persistent storage');
+            // } catch (saveError) {
+            //   console.error('❌ Failed to save session:', saveError);
+            //   throw saveError;
+            // }
+            console.error('⚠️ Session storage disabled - credentials not persisted to disk');
+            const expirationDate = new Date(this.session.expiresAt).toLocaleString();
+            console.error('✅ Authentication successful for user:', userInfoResponse.data.email);
+            console.error('💾 Session saved and expires at:', expirationDate);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const responseData = error?.response?.data;
+            console.error('❌ Token exchange failed:', responseData || errorMessage);
+            throw new Error('Failed to exchange authorization code for tokens');
+        }
+    }
+}

package/dist/auth/sessionCache.d.ts

@@ -0,0 +1,5 @@
+import { AuthenticationManager } from "./authManager.js";
+export declare function getOrCreateSession(username: string, password: string): Promise<AuthenticationManager>;
+export declare function invalidateSession(username: string): void;
+export declare function invalidateSessionByToken(token: string): void;
+//# sourceMappingURL=sessionCache.d.ts.map

package/dist/auth/sessionCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionCache.d.ts","sourceRoot":"","sources":["../../src/auth/sessionCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAKzD,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAY3G;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAGxD;AAGD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAQ5D"}

package/dist/auth/sessionCache.js

@@ -0,0 +1,29 @@
+import { AuthenticationManager } from "./authManager.js";
+// In-memory token cache keyed by username
+const cache = new Map();
+export async function getOrCreateSession(username, password) {
+    const cached = cache.get(username);
+    if (cached && cached.isAuthenticated()) {
+        return cached;
+    }
+    // First request or token expired — login fresh
+    console.log(`Logging in: ${username}`);
+    const manager = await AuthenticationManager.login(username, password);
+    cache.set(username, manager);
+    console.log(`Session created for: ${username}`);
+    return manager;
+}
+export function invalidateSession(username) {
+    cache.delete(username);
+    console.log(`Session invalidated for: ${username}`);
+}
+// Called by tool handlers when an API call gets a 401 — token rejected by PerfAI
+export function invalidateSessionByToken(token) {
+    for (const [username, manager] of cache.entries()) {
+        if (manager.getAccessToken() === token) {
+            cache.delete(username);
+            console.log(`Session evicted (token rejected) for: ${username}`);
+            return;
+        }
+    }
+}

package/dist/auth/sessionStorage.d.ts

@@ -0,0 +1,53 @@
+import { UserSession } from './types.js';
+/**
+ * Secure session storage for MCP PerfAI server
+ * Handles persistent storage of authentication sessions with encryption
+ */
+export declare class SessionStorage {
+    private readonly storageDir;
+    private readonly sessionFile;
+    private readonly keyFile;
+    private encryptionKey;
+    constructor(appName?: string);
+    /**
+     * Get OS-specific configuration directory
+     */
+    private getConfigDirectory;
+    /**
+     * Ensure storage directory exists
+     */
+    private ensureStorageDirectory;
+    /**
+     * Initialize or load encryption key
+     */
+    private initializeEncryptionKey;
+    /**
+     * Encrypt data using AES-256-CBC
+     */
+    private encrypt;
+    /**
+     * Decrypt data using AES-256-CBC
+     */
+    private decrypt;
+    /**
+     * Save session to persistent storage
+     */
+    saveSession(session: UserSession): Promise<void>;
+    /**
+     * Load session from persistent storage
+     */
+    loadSession(): Promise<UserSession | null>;
+    /**
+     * Clear stored session
+     */
+    clearSession(): void;
+    /**
+     * Check if session exists and is valid
+     */
+    hasValidSession(): boolean;
+    /**
+     * Get session storage location (for debugging)
+     */
+    getStorageLocation(): string;
+}
+//# sourceMappingURL=sessionStorage.d.ts.map

package/dist/auth/sessionStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStorage.d.ts","sourceRoot":"","sources":["../../src/auth/sessionStorage.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,aAAa,CAAuB;gBAEhC,OAAO,GAAE,MAAqB;IAU1C;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAW9B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAiB/B;;OAEG;IACH,OAAO,CAAC,OAAO;IAqBf;;OAEG;IACH,OAAO,CAAC,OAAO;IA4Bf;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BtD;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IA+ChD;;OAEG;IACH,YAAY,IAAI,IAAI;IAWpB;;OAEG;IACH,eAAe,IAAI,OAAO;IAoB1B;;OAEG;IACH,kBAAkB,IAAI,MAAM;CAG7B"}