@toolprint/hypertool-mcp/dist/config/environment.js

HyperTool MCP proxy server for routing requests between clients and multiple underlying MCP servers

/**
 * Environment configuration for HyperTool MCP
 * Supports production and test modes with configurable paths
 */
import { join } from "path";
import { homedir } from "os";
/**
 * Environment mode enumeration
 */
export var EnvironmentMode;
(function (EnvironmentMode) {
    EnvironmentMode["PRODUCTION"] = "production";
    EnvironmentMode["TEST"] = "test";
})(EnvironmentMode || (EnvironmentMode = {}));
/**
 * Environment configuration manager
 */
export class EnvironmentManager {
    static instance;
    config;
    constructor() {
        // Default to production mode
        this.config = this.createProductionConfig();
        // Load any environment overrides
        this.loadFromEnv();
    }
    /**
     * Get singleton instance
     */
    static getInstance() {
        if (!EnvironmentManager.instance) {
            EnvironmentManager.instance = new EnvironmentManager();
        }
        return EnvironmentManager.instance;
    }
    /**
     * Create production configuration
     */
    createProductionConfig() {
        const configRoot = join(homedir(), ".toolprint/hypertool-mcp");
        return {
            mode: EnvironmentMode.PRODUCTION,
            configRoot,
            registryPath: join(configRoot, "apps/registry.json"),
            backupPath: join(configRoot, "backups"),
            cachePath: join(configRoot, "cache"),
        };
    }
    /**
     * Create test configuration
     */
    createTestConfig(baseDir) {
        const configRoot = join(baseDir, ".toolprint/hypertool-mcp");
        return {
            mode: EnvironmentMode.TEST,
            configRoot,
            registryPath: join(configRoot, "apps/registry.json"),
            backupPath: join(configRoot, "backups"),
            cachePath: join(configRoot, "cache"),
        };
    }
    /**
     * Get current configuration
     */
    getConfig() {
        return { ...this.config };
    }
    /**
     * Set environment mode
     */
    setMode(mode, testBaseDir) {
        if (mode === EnvironmentMode.TEST) {
            if (!testBaseDir) {
                throw new Error("Test base directory must be provided for test mode");
            }
            this.config = this.createTestConfig(testBaseDir);
        }
        else {
            this.config = this.createProductionConfig();
        }
    }
    /**
     * Override specific configuration values
     */
    override(overrides) {
        this.config = {
            ...this.config,
            ...overrides,
        };
    }
    /**
     * Check if running in test mode
     */
    isTestMode() {
        return this.config.mode === EnvironmentMode.TEST;
    }
    /**
     * Check if running in production mode
     */
    isProductionMode() {
        return this.config.mode === EnvironmentMode.PRODUCTION;
    }
    /**
     * Load configuration from environment variables
     */
    loadFromEnv() {
        const mode = process.env.HYPERTOOL_ENV;
        const configRoot = process.env.HYPERTOOL_CONFIG_ROOT;
        if (mode === EnvironmentMode.TEST || mode === EnvironmentMode.PRODUCTION) {
            this.config.mode = mode;
        }
        if (configRoot) {
            this.config.configRoot = configRoot;
            // Update derived paths
            this.config.registryPath = join(configRoot, "apps/registry.json");
            this.config.backupPath = join(configRoot, "backups");
            this.config.cachePath = join(configRoot, "cache");
        }
    }
    /**
     * Reset to default configuration
     */
    reset() {
        this.config = this.createProductionConfig();
    }
}
/**
 * Convenience function to get environment config
 */
export function getEnvironmentConfig() {
    return EnvironmentManager.getInstance().getConfig();
}
/**
 * Convenience function to check if in test mode
 */
export function isTestMode() {
    return EnvironmentManager.getInstance().isTestMode();
}
/**
 * Load feature flags from config.json
 */
async function loadFeatureFlagsFromConfig() {
    try {
        // Dynamic import to avoid circular dependencies
        const { getFeatureFlags } = await import("./preferenceStore.js");
        return await getFeatureFlags();
    }
    catch (error) {
        // If we can't load from config file, return undefined
        return undefined;
    }
}
//# sourceMappingURL=environment.js.map