vibe-coder-mcp/build/testUtils/env-cleanup-manager.js

Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.

import logger from '../logger.js';
export class EnvCleanupManager {
    static originalEnv = {};
    static isInitialized = false;
    static isTestEnvironment = false;
    static trackedKeys = new Set();
    static initialize() {
        if (process.env.NODE_ENV !== 'test' && !process.env.VITEST) {
            logger.warn('EnvCleanupManager should only be used in test environment');
            return;
        }
        this.isTestEnvironment = true;
        this.createSnapshot();
        this.isInitialized = true;
        logger.debug('EnvCleanupManager initialized for test environment');
    }
    static createSnapshot() {
        if (!this.isTestEnvironment) {
            return;
        }
        this.originalEnv = { ...process.env };
        this.trackedKeys.clear();
        logger.debug('Environment snapshot created');
    }
    static trackVariable(key) {
        if (!this.isTestEnvironment) {
            return;
        }
        this.trackedKeys.add(key);
        if (!(key in this.originalEnv)) {
            this.originalEnv[key] = process.env[key];
        }
        logger.debug({ key }, 'Environment variable tracked for cleanup');
    }
    static setVariable(key, value) {
        if (!this.isTestEnvironment) {
            logger.warn('EnvCleanupManager can only set variables in test environment');
            return;
        }
        this.trackVariable(key);
        process.env[key] = value;
        logger.debug({ key, value }, 'Environment variable set with tracking');
    }
    static deleteVariable(key) {
        if (!this.isTestEnvironment) {
            logger.warn('EnvCleanupManager can only delete variables in test environment');
            return;
        }
        this.trackVariable(key);
        delete process.env[key];
        logger.debug({ key }, 'Environment variable deleted with tracking');
    }
    static restoreEnvironment() {
        if (!this.isTestEnvironment || !this.isInitialized) {
            return;
        }
        const startTime = Date.now();
        let restoredCount = 0;
        let deletedCount = 0;
        for (const key of this.trackedKeys) {
            const originalValue = this.originalEnv[key];
            if (originalValue === undefined) {
                delete process.env[key];
                deletedCount++;
            }
            else {
                process.env[key] = originalValue;
                restoredCount++;
            }
        }
        const duration = Date.now() - startTime;
        logger.debug({
            restoredCount,
            deletedCount,
            totalTracked: this.trackedKeys.size,
            duration
        }, 'Environment variables restored');
        this.trackedKeys.clear();
    }
    static restoreAllEnvironment() {
        if (!this.isTestEnvironment || !this.isInitialized) {
            return;
        }
        const startTime = Date.now();
        let restoredCount = 0;
        let deletedCount = 0;
        const currentKeys = Object.keys(process.env);
        for (const [key, value] of Object.entries(this.originalEnv)) {
            if (value === undefined) {
                delete process.env[key];
                deletedCount++;
            }
            else {
                process.env[key] = value;
                restoredCount++;
            }
        }
        for (const key of currentKeys) {
            if (!(key in this.originalEnv)) {
                delete process.env[key];
                deletedCount++;
            }
        }
        const duration = Date.now() - startTime;
        logger.debug({
            restoredCount,
            deletedCount,
            totalOriginal: Object.keys(this.originalEnv).length,
            duration
        }, 'Full environment restoration completed');
    }
    static getEnvironmentDiff() {
        if (!this.isTestEnvironment || !this.isInitialized) {
            return { added: [], modified: [], deleted: [] };
        }
        const added = [];
        const modified = [];
        const deleted = [];
        for (const [key, currentValue] of Object.entries(process.env)) {
            const originalValue = this.originalEnv[key];
            if (originalValue === undefined) {
                added.push(key);
            }
            else if (originalValue !== currentValue) {
                modified.push(key);
            }
        }
        for (const [key, originalValue] of Object.entries(this.originalEnv)) {
            if (originalValue !== undefined && !(key in process.env)) {
                deleted.push(key);
            }
        }
        return { added, modified, deleted };
    }
    static getTrackedVariables() {
        return Array.from(this.trackedKeys);
    }
    static clearTracking() {
        if (!this.isTestEnvironment) {
            return;
        }
        this.trackedKeys.clear();
        this.originalEnv = {};
        logger.debug('Environment tracking cleared');
    }
    static isManagerInitialized() {
        return this.isInitialized && this.isTestEnvironment;
    }
}
export function setTestEnvVar(key, value) {
    EnvCleanupManager.setVariable(key, value);
}
export function deleteTestEnvVar(key) {
    EnvCleanupManager.deleteVariable(key);
}
export function withTestEnvVars(envVars, callback) {
    for (const [key, value] of Object.entries(envVars)) {
        EnvCleanupManager.setVariable(key, value);
    }
    try {
        return callback();
    }
    finally {
    }
}
export function initializeEnvCleanupManager() {
    EnvCleanupManager.initialize();
}
export function restoreTestEnvironment() {
    EnvCleanupManager.restoreEnvironment();
}
export function restoreAllTestEnvironment() {
    EnvCleanupManager.restoreAllEnvironment();
}