il2cpp-dump-analyzer-mcp
Version:
Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games
228 lines ā¢ 11 kB
JavaScript
;
/**
* Transport configuration management for IL2CPP MCP Server
* Handles environment variables and validation for different transport types
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.TRANSPORT_ENV_VARS = exports.DEFAULT_TRANSPORT_CONFIG = exports.TransportType = void 0;
exports.loadTransportConfig = loadTransportConfig;
exports.validateTransportConfig = validateTransportConfig;
exports.getValidatedTransportConfig = getValidatedTransportConfig;
exports.createTransportConfig = createTransportConfig;
exports.getEnvironmentVariableDocumentation = getEnvironmentVariableDocumentation;
exports.printTransportConfigSummary = printTransportConfigSummary;
const zod_1 = require("zod");
const transport_types_1 = require("./transport-types");
// Re-export TransportType and DEFAULT_TRANSPORT_CONFIG for convenience
var transport_types_2 = require("./transport-types");
Object.defineProperty(exports, "TransportType", { enumerable: true, get: function () { return transport_types_2.TransportType; } });
Object.defineProperty(exports, "DEFAULT_TRANSPORT_CONFIG", { enumerable: true, get: function () { return transport_types_2.DEFAULT_TRANSPORT_CONFIG; } });
/**
* Zod schema for transport configuration validation
*/
const TransportConfigSchema = zod_1.z.object({
type: zod_1.z.nativeEnum(transport_types_1.TransportType),
host: zod_1.z.string().min(1).optional(),
port: zod_1.z.number().int().min(1).max(65535).optional(),
enableCors: zod_1.z.boolean().optional(),
apiKey: zod_1.z.string().optional(),
sessionTimeout: zod_1.z.number().int().min(1000).optional(), // Minimum 1 second
enableLogging: zod_1.z.boolean().optional(),
maxRequestSize: zod_1.z.number().int().min(1024).optional(), // Minimum 1KB
rateLimitRpm: zod_1.z.number().int().min(1).optional(),
enableSsl: zod_1.z.boolean().optional(),
sslCertPath: zod_1.z.string().optional(),
sslKeyPath: zod_1.z.string().optional()
}).refine((config) => {
// SSL validation: if SSL is enabled, cert and key paths are required
if (config.enableSsl) {
return config.sslCertPath && config.sslKeyPath;
}
return true;
}, {
message: "SSL certificate and key paths are required when SSL is enabled"
});
/**
* Environment variable names for transport configuration
*/
exports.TRANSPORT_ENV_VARS = {
TYPE: 'MCP_TRANSPORT',
HOST: 'MCP_HOST',
PORT: 'MCP_PORT',
ENABLE_CORS: 'MCP_ENABLE_CORS',
API_KEY: 'MCP_API_KEY',
SESSION_TIMEOUT: 'MCP_SESSION_TIMEOUT',
ENABLE_LOGGING: 'MCP_ENABLE_LOGGING',
MAX_REQUEST_SIZE: 'MCP_MAX_REQUEST_SIZE',
RATE_LIMIT_RPM: 'MCP_RATE_LIMIT_RPM',
ENABLE_SSL: 'MCP_ENABLE_SSL',
SSL_CERT_PATH: 'MCP_SSL_CERT_PATH',
SSL_KEY_PATH: 'MCP_SSL_KEY_PATH'
};
/**
* Parse boolean from environment variable
*/
function parseBoolean(value, defaultValue) {
if (!value)
return defaultValue;
return value.toLowerCase() === 'true' || value === '1';
}
/**
* Parse integer from environment variable
*/
function parseInteger(value, defaultValue) {
if (!value)
return defaultValue;
const parsed = parseInt(value, 10);
return isNaN(parsed) ? defaultValue : parsed;
}
/**
* Load transport configuration from environment variables
*/
function loadTransportConfig() {
const config = {
type: process.env[exports.TRANSPORT_ENV_VARS.TYPE] || transport_types_1.DEFAULT_TRANSPORT_CONFIG.type,
host: process.env[exports.TRANSPORT_ENV_VARS.HOST] || transport_types_1.DEFAULT_TRANSPORT_CONFIG.host,
port: parseInteger(process.env[exports.TRANSPORT_ENV_VARS.PORT], transport_types_1.DEFAULT_TRANSPORT_CONFIG.port),
enableCors: parseBoolean(process.env[exports.TRANSPORT_ENV_VARS.ENABLE_CORS], transport_types_1.DEFAULT_TRANSPORT_CONFIG.enableCors),
apiKey: process.env[exports.TRANSPORT_ENV_VARS.API_KEY] || transport_types_1.DEFAULT_TRANSPORT_CONFIG.apiKey,
sessionTimeout: parseInteger(process.env[exports.TRANSPORT_ENV_VARS.SESSION_TIMEOUT], transport_types_1.DEFAULT_TRANSPORT_CONFIG.sessionTimeout),
enableLogging: parseBoolean(process.env[exports.TRANSPORT_ENV_VARS.ENABLE_LOGGING], transport_types_1.DEFAULT_TRANSPORT_CONFIG.enableLogging),
maxRequestSize: parseInteger(process.env[exports.TRANSPORT_ENV_VARS.MAX_REQUEST_SIZE], transport_types_1.DEFAULT_TRANSPORT_CONFIG.maxRequestSize),
rateLimitRpm: parseInteger(process.env[exports.TRANSPORT_ENV_VARS.RATE_LIMIT_RPM], transport_types_1.DEFAULT_TRANSPORT_CONFIG.rateLimitRpm),
enableSsl: parseBoolean(process.env[exports.TRANSPORT_ENV_VARS.ENABLE_SSL], transport_types_1.DEFAULT_TRANSPORT_CONFIG.enableSsl),
sslCertPath: process.env[exports.TRANSPORT_ENV_VARS.SSL_CERT_PATH] || transport_types_1.DEFAULT_TRANSPORT_CONFIG.sslCertPath,
sslKeyPath: process.env[exports.TRANSPORT_ENV_VARS.SSL_KEY_PATH] || transport_types_1.DEFAULT_TRANSPORT_CONFIG.sslKeyPath
};
return config;
}
/**
* Validate transport configuration
*/
function validateTransportConfig(config) {
try {
TransportConfigSchema.parse(config);
// Additional validation
const errors = [];
// Validate transport type
if (!Object.values(transport_types_1.TransportType).includes(config.type)) {
errors.push(`Invalid transport type: ${config.type}. Supported types: ${Object.values(transport_types_1.TransportType).join(', ')}`);
}
// Validate network transport requirements
if (config.type !== transport_types_1.TransportType.STDIO) {
if (!config.host) {
errors.push('Host is required for network transports');
}
if (!config.port || config.port < 1 || config.port > 65535) {
errors.push('Valid port (1-65535) is required for network transports');
}
}
// Validate SSL configuration
if (config.enableSsl) {
if (!config.sslCertPath) {
errors.push('SSL certificate path is required when SSL is enabled');
}
if (!config.sslKeyPath) {
errors.push('SSL private key path is required when SSL is enabled');
}
}
// Validate rate limiting
if (config.rateLimitRpm && config.rateLimitRpm < 1) {
errors.push('Rate limit must be at least 1 request per minute');
}
// Validate session timeout
if (config.sessionTimeout && config.sessionTimeout < 1000) {
errors.push('Session timeout must be at least 1000ms (1 second)');
}
return {
valid: errors.length === 0,
errors
};
}
catch (error) {
if (error instanceof zod_1.z.ZodError) {
return {
valid: false,
errors: error.errors.map(e => `${e.path.join('.')}: ${e.message}`)
};
}
return {
valid: false,
errors: [`Configuration validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`]
};
}
}
/**
* Get transport configuration with validation
*/
function getValidatedTransportConfig() {
const config = loadTransportConfig();
const validation = validateTransportConfig(config);
if (!validation.valid) {
throw new Error(`Invalid transport configuration:\n${validation.errors.join('\n')}`);
}
return config;
}
/**
* Create transport configuration for specific type
*/
function createTransportConfig(type, overrides = {}) {
const baseConfig = { ...transport_types_1.DEFAULT_TRANSPORT_CONFIG };
// Apply type-specific defaults
switch (type) {
case transport_types_1.TransportType.STDIO:
// No additional configuration needed for stdio
break;
case transport_types_1.TransportType.HTTP:
case transport_types_1.TransportType.SSE:
baseConfig.port = 3000;
baseConfig.enableCors = true;
break;
case transport_types_1.TransportType.WEBSOCKET:
baseConfig.port = 3001;
baseConfig.enableCors = true;
break;
}
return {
...baseConfig,
type,
...overrides
};
}
/**
* Get environment variable documentation
*/
function getEnvironmentVariableDocumentation() {
return {
[exports.TRANSPORT_ENV_VARS.TYPE]: `Transport type (${Object.values(transport_types_1.TransportType).join('|')}) - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.type}`,
[exports.TRANSPORT_ENV_VARS.HOST]: `Server host for network transports - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.host}`,
[exports.TRANSPORT_ENV_VARS.PORT]: `Server port for network transports - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.port}`,
[exports.TRANSPORT_ENV_VARS.ENABLE_CORS]: `Enable CORS for network transports - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.enableCors}`,
[exports.TRANSPORT_ENV_VARS.API_KEY]: `API key for authentication (optional) - default: none`,
[exports.TRANSPORT_ENV_VARS.SESSION_TIMEOUT]: `Session timeout in milliseconds - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.sessionTimeout}`,
[exports.TRANSPORT_ENV_VARS.ENABLE_LOGGING]: `Enable request logging - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.enableLogging}`,
[exports.TRANSPORT_ENV_VARS.MAX_REQUEST_SIZE]: `Maximum request size in bytes - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.maxRequestSize}`,
[exports.TRANSPORT_ENV_VARS.RATE_LIMIT_RPM]: `Rate limit in requests per minute - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.rateLimitRpm}`,
[exports.TRANSPORT_ENV_VARS.ENABLE_SSL]: `Enable SSL/TLS for HTTPS - default: ${transport_types_1.DEFAULT_TRANSPORT_CONFIG.enableSsl}`,
[exports.TRANSPORT_ENV_VARS.SSL_CERT_PATH]: `SSL certificate file path (required if SSL enabled) - default: none`,
[exports.TRANSPORT_ENV_VARS.SSL_KEY_PATH]: `SSL private key file path (required if SSL enabled) - default: none`
};
}
/**
* Print transport configuration summary
*/
function printTransportConfigSummary(config) {
console.log('\nš Transport Configuration:');
console.log(` Type: ${config.type}`);
if (config.type !== transport_types_1.TransportType.STDIO) {
console.log(` Host: ${config.host}`);
console.log(` Port: ${config.port}`);
console.log(` CORS: ${config.enableCors ? 'enabled' : 'disabled'}`);
console.log(` SSL: ${config.enableSsl ? 'enabled' : 'disabled'}`);
console.log(` Auth: ${config.apiKey ? 'API key configured' : 'no authentication'}`);
console.log(` Rate Limit: ${config.rateLimitRpm} requests/minute`);
console.log(` Logging: ${config.enableLogging ? 'enabled' : 'disabled'}`);
}
console.log('');
}
//# sourceMappingURL=transport-config.js.map