monora-ai 2.0.0 → 2.1.3

package/dist/config_migrations.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LATEST_CONFIG_VERSION = void 0;
 exports.applyConfigMigrations = applyConfigMigrations;
+exports.validateProductionReadiness = validateProductionReadiness;
+exports.checkPresetEnvironmentMismatch = checkPresetEnvironmentMismatch;
+exports.logProductionWarnings = logProductionWarnings;
 const logger_1 = require("./logger");
 exports.LATEST_CONFIG_VERSION = '1.0.0';
 function applyConfigMigrations(config) {
@@ -15,12 +18,14 @@ function applyConfigMigrations(config) {
         if (!config.config_version) {
             config.config_version = exports.LATEST_CONFIG_VERSION;
         }
+        normalizeOnboarding(config);
         return config;
     }
     if (compareVersions(version, '1.0.0') < 0) {
         migrate000To100(config);
         config.config_version = exports.LATEST_CONFIG_VERSION;
     }
+    normalizeOnboarding(config);
     return config;
 }
 function compareVersions(left, right) {
@@ -159,3 +164,203 @@ function normalizeErrorHandling(config) {
         }
     }
 }
+function normalizeOnboarding(config) {
+    const cfg = config;
+    if (!cfg.onboarding && cfg.onboard && typeof cfg.onboard === 'object') {
+        cfg.onboarding = cfg.onboard;
+        delete cfg.onboard;
+    }
+    if (cfg.onboarding && typeof cfg.onboarding === 'object') {
+        const onboarding = cfg.onboarding;
+        if (onboarding.require_in_production !== undefined && onboarding.required_in_production === undefined) {
+            onboarding.required_in_production = onboarding.require_in_production;
+        }
+        if (typeof onboarding.status === 'string') {
+            const status = onboarding.status.toLowerCase();
+            if (['draft', 'validated', 'completed'].includes(status)) {
+                onboarding.status = status;
+            }
+            else {
+                onboarding.status = 'draft';
+            }
+        }
+        const artifacts = onboarding.artifacts;
+        if (artifacts && typeof artifacts === 'object') {
+            if (artifacts.input_path && !artifacts.production_logs_path) {
+                artifacts.production_logs_path = artifacts.input_path;
+            }
+            if (artifacts.schema_path && !artifacts.schema_contract_path) {
+                artifacts.schema_contract_path = artifacts.schema_path;
+            }
+        }
+    }
+    if (!cfg.enrichments && cfg.enrichment && typeof cfg.enrichment === 'object') {
+        cfg.enrichments = cfg.enrichment;
+        delete cfg.enrichment;
+    }
+}
+/**
+ * Validate configuration against production best practices.
+ *
+ * Returns a list of warnings for settings that may not be appropriate
+ * for production use.
+ *
+ * @param config - The Monora configuration object.
+ * @returns List of ProductionReadinessWarning objects.
+ *
+ * @example
+ * ```typescript
+ * const warnings = validateProductionReadiness(config);
+ * for (const w of warnings) {
+ *   console.log(`[${w.category}] ${w.message}`);
+ *   console.log(`  Recommendation: ${w.recommendation}`);
+ * }
+ * ```
+ */
+function validateProductionReadiness(config) {
+    const warnings = [];
+    // Check environment
+    const defaults = config.defaults || {};
+    const environment = defaults.environment || 'development';
+    // Only run these checks in production
+    if (environment !== 'production') {
+        return warnings;
+    }
+    // Check immutability settings
+    const immutability = config.immutability || {};
+    if (immutability.enabled === false) {
+        warnings.push({
+            category: 'security',
+            message: 'Immutability (hash chaining) is disabled',
+            recommendation: 'Enable immutability.enabled=true for tamper-evident audit trails',
+        });
+    }
+    if (!immutability.verify_on_emit) {
+        warnings.push({
+            category: 'security',
+            message: 'Hash verification on emit is disabled',
+            recommendation: 'Enable immutability.verify_on_emit=true to detect chain tampering',
+        });
+    }
+    // Check signing settings
+    const signing = config.signing || {};
+    if (!signing.enabled) {
+        warnings.push({
+            category: 'security',
+            message: 'Event signing is disabled',
+            recommendation: 'Enable signing.enabled=true with Ed25519 or HMAC-SHA256 for cryptographic integrity',
+        });
+    }
+    // Check sinks configuration
+    const sinks = config.sinks || [];
+    const hasPersistentSink = sinks.some((sink) => sink.type === 'file' || sink.type === 'https');
+    if (!hasPersistentSink) {
+        warnings.push({
+            category: 'durability',
+            message: 'No persistent sink configured (only stdout)',
+            recommendation: 'Add a file or https sink to ensure events are persisted',
+        });
+    }
+    // Check WAL settings
+    const wal = config.wal || {};
+    if (!wal.enabled) {
+        warnings.push({
+            category: 'durability',
+            message: 'Write-ahead log (WAL) is disabled',
+            recommendation: 'Enable wal.enabled=true for crash recovery',
+        });
+    }
+    else if (wal.sync_mode === 'none') {
+        warnings.push({
+            category: 'durability',
+            message: "WAL sync mode is 'none' (data may be lost on crash)",
+            recommendation: "Set wal.sync_mode='fsync' (avoid 'none') for durability",
+        });
+    }
+    // Check error handling
+    const errorHandling = config.error_handling || {};
+    if (errorHandling.sink_failure_mode === 'silent') {
+        warnings.push({
+            category: 'observability',
+            message: 'Sink failures are silently ignored',
+            recommendation: "Set error_handling.sink_failure_mode='warn' or 'raise'",
+        });
+    }
+    // Check reporting
+    const reporting = config.reporting || {};
+    if (reporting.enabled === false) {
+        warnings.push({
+            category: 'compliance',
+            message: 'Trust summary reporting is disabled',
+            recommendation: 'Enable reporting.enabled=true for compliance documentation',
+        });
+    }
+    // Check data handling for sensitive data
+    const dataHandling = config.data_handling || {};
+    if (!dataHandling.enabled) {
+        warnings.push({
+            category: 'privacy',
+            message: 'Data handling/redaction is disabled',
+            recommendation: 'Enable data_handling.enabled=true to prevent PII leakage',
+        });
+    }
+    // Check policies
+    const policies = config.policies || {};
+    if (!policies.enforce) {
+        warnings.push({
+            category: 'governance',
+            message: 'Model policy enforcement is disabled',
+            recommendation: 'Enable policies.enforce=true with model_allowlist for governance',
+        });
+    }
+    return warnings;
+}
+/**
+ * Check if a preset is appropriate for the given environment.
+ *
+ * @param presetName - Name of the preset being used.
+ * @param environment - Target environment.
+ * @returns Warning if there's a mismatch, null otherwise.
+ */
+function checkPresetEnvironmentMismatch(presetName, environment) {
+    if (!presetName) {
+        return null;
+    }
+    const presetLower = presetName.toLowerCase();
+    const envLower = environment.toLowerCase();
+    // Development/POC presets in production
+    if (envLower === 'production' && ['development', 'dev', 'poc', 'experimental'].includes(presetLower)) {
+        return {
+            category: 'configuration',
+            message: `Using '${presetName}' preset in production environment`,
+            recommendation: "Switch to 'production' or 'strict_enterprise' preset for production use",
+        };
+    }
+    // Strict enterprise in development (overkill warning)
+    if (['development', 'dev'].includes(envLower) && presetLower === 'strict_enterprise') {
+        return {
+            category: 'configuration',
+            message: `Using '${presetName}' preset in development - may slow iteration`,
+            recommendation: "Consider 'development' or 'poc' preset for faster local development",
+        };
+    }
+    return null;
+}
+/**
+ * Log production readiness warnings.
+ *
+ * @param warnings - List of warnings to log.
+ */
+function logProductionWarnings(warnings) {
+    if (warnings.length === 0) {
+        return;
+    }
+    logger_1.logger.warning('='.repeat(60));
+    logger_1.logger.warning('PRODUCTION READINESS WARNINGS (%d issues)', warnings.length);
+    logger_1.logger.warning('='.repeat(60));
+    for (const w of warnings) {
+        logger_1.logger.warning('[%s] %s', w.category.toUpperCase(), w.message);
+        logger_1.logger.warning('  → %s', w.recommendation);
+    }
+    logger_1.logger.warning('='.repeat(60));
+}