claudepod 1.0.2 → 1.1.0

package/.devcontainer/sanitize-system-prompt.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Sanitize system prompt markdown for Claude CLI usage
+# This script converts a markdown file to a format suitable for --append-system-prompt
+
+set -euo pipefail
+
+if [ $# -eq 0 ]; then
+    echo "Usage: $0 <markdown-file>"
+    exit 1
+fi
+
+MARKDOWN_FILE="$1"
+
+if [ ! -f "$MARKDOWN_FILE" ]; then
+    echo "Error: File '$MARKDOWN_FILE' not found"
+    exit 1
+fi
+
+# Read the markdown file and perform sanitization
+cat "$MARKDOWN_FILE" | \
+    # Remove leading/trailing whitespace from each line
+    sed 's/^[[:space:]]*//; s/[[:space:]]*$//' | \
+    # Escape double quotes
+    sed 's/"/\\"/g' | \
+    # Escape backslashes
+    sed 's/\\/\\\\/g' | \
+    # Join all lines with literal \n
+    tr '\n' '\001' | \
+    sed 's/\001/\\n/g' | \
+    # Remove any trailing \n
+    sed 's/\\n$//'

package/.devcontainer/scripts/config/claude-core.sh

@@ -0,0 +1,210 @@
+#!/bin/bash
+
+# Claude Core Configuration Module
+# Handles Claude directory creation and core configuration files
+
+setup_claude_core_config() {
+    echo "🔧 Setting up Claude core configuration..."
+    
+    # Claude Code uses multiple possible config locations
+    local claude_dirs=(
+        "/home/node/.claude"
+        "/home/node/.config/claude"
+    )
+    
+    for dir in "${claude_dirs[@]}"; do
+        if [ ! -d "$dir" ]; then
+            mkdir -p "$dir"
+            echo "📁 Created configuration directory: $dir"
+        fi
+        # Set proper permissions
+        chown -R node:node "$dir"
+        chmod -R 700 "$dir"
+    done
+    
+    # Copy optimized settings.json from devcontainer config
+    setup_claude_settings
+    
+    # Copy MCP configuration
+    setup_claude_mcp_config
+    
+    # Copy system prompt
+    setup_claude_system_prompt
+    
+    # Copy output styles
+    setup_claude_output_styles
+    
+    echo "📋 Claude core configuration processing completed"
+}
+
+setup_claude_settings() {
+    local settings_source="/workspace/.devcontainer/config/claude/settings.json"
+    local settings_target_home="/home/node/.claude/settings.json"
+    local settings_target_workspace="/workspace/.claude/settings.json"
+    
+    if [ ! -f "$settings_source" ]; then
+        echo "⚠️  Claude settings template not found, using defaults"
+        return 1
+    fi
+    
+    # Check if we should override existing files or only create if missing
+    local copy_settings=false
+    if [ "${OVERRIDE_CLAUDE_SETTINGS:-false}" = "true" ]; then
+        echo "📝 OVERRIDE_CLAUDE_SETTINGS=true: Forcing overwrite of Claude settings"
+        copy_settings=true
+    elif [ ! -f "$settings_target_home" ] && [ ! -f "$settings_target_workspace" ]; then
+        echo "📝 Creating Claude settings (no existing files found)"
+        copy_settings=true
+    else
+        echo "📁 Preserving existing Claude settings (set OVERRIDE_CLAUDE_SETTINGS=true to overwrite)"
+    fi
+    
+    if [ "$copy_settings" = "true" ]; then
+        # Create backups of existing configurations
+        create_config_backup "$settings_target_home"
+        create_config_backup "$settings_target_workspace"
+        
+        # Copy to home directory (will be bind-mounted to workspace)
+        cp "$settings_source" "$settings_target_home"
+        chown node:node "$settings_target_home"
+        chmod 600 "$settings_target_home"
+        
+        # Also copy directly to workspace for redundancy
+        cp "$settings_source" "$settings_target_workspace"
+        chown node:node "$settings_target_workspace"
+        chmod 600 "$settings_target_workspace"
+        
+        echo "📋 Claude settings configured"
+    fi
+}
+
+setup_claude_mcp_config() {
+    local mcp_source="/workspace/.devcontainer/config/claude/mcp.json"
+    local mcp_target_home="/home/node/.claude/mcp.json"
+    local mcp_target_workspace="/workspace/.claude/mcp.json"
+    
+    if [ ! -f "$mcp_source" ]; then
+        echo "📝 MCP configuration template not found, will be generated in post-start phase"
+        return 0
+    fi
+    
+    local copy_mcp=false
+    if [ "${OVERRIDE_CLAUDE_MCP:-false}" = "true" ]; then
+        echo "📝 OVERRIDE_CLAUDE_MCP=true: Forcing overwrite of Claude MCP configuration"
+        copy_mcp=true
+    elif [ ! -f "$mcp_target_home" ] && [ ! -f "$mcp_target_workspace" ]; then
+        echo "📝 Creating Claude MCP configuration (no existing files found)"
+        copy_mcp=true
+    else
+        echo "📁 Preserving existing Claude MCP configuration (set OVERRIDE_CLAUDE_MCP=true to overwrite)"
+    fi
+    
+    if [ "$copy_mcp" = "true" ]; then
+        # Create backups of existing MCP configurations
+        create_config_backup "$mcp_target_home"
+        create_config_backup "$mcp_target_workspace"
+        
+        cp "$mcp_source" "$mcp_target_home"
+        cp "$mcp_source" "$mcp_target_workspace"
+        chown node:node "$mcp_target_home" "$mcp_target_workspace"
+        chmod 600 "$mcp_target_home" "$mcp_target_workspace"
+        
+        echo "📋 Claude MCP configuration set up"
+    fi
+}
+
+setup_claude_system_prompt() {
+    local prompt_source="/workspace/.devcontainer/config/claude/system-prompt.md"
+    local prompt_target_home="/home/node/.claude/system-prompt.md"
+    local prompt_target_workspace="/workspace/.claude/system-prompt.md"
+    
+    if [ ! -f "$prompt_source" ]; then
+        echo "📝 System prompt template not found, skipping"
+        return 0
+    fi
+    
+    local copy_prompt=false
+    if [ "${OVERRIDE_CLAUDE_SYSTEM_PROMPT:-false}" = "true" ]; then
+        echo "📝 OVERRIDE_CLAUDE_SYSTEM_PROMPT=true: Forcing overwrite of Claude system prompt"
+        copy_prompt=true
+    elif [ ! -f "$prompt_target_home" ] && [ ! -f "$prompt_target_workspace" ]; then
+        echo "📝 Creating Claude system prompt (no existing files found)"
+        copy_prompt=true
+    else
+        echo "📁 Preserving existing Claude system prompt (set OVERRIDE_CLAUDE_SYSTEM_PROMPT=true to overwrite)"
+    fi
+    
+    if [ "$copy_prompt" = "true" ]; then
+        # Create backups of existing system prompt configurations
+        create_config_backup "$prompt_target_home"
+        create_config_backup "$prompt_target_workspace"
+        
+        cp "$prompt_source" "$prompt_target_home"
+        cp "$prompt_source" "$prompt_target_workspace"
+        chown node:node "$prompt_target_home" "$prompt_target_workspace"
+        chmod 600 "$prompt_target_home" "$prompt_target_workspace"
+        
+        echo "📋 Claude system prompt configured"
+    fi
+}
+
+setup_claude_output_styles() {
+    local styles_source="/workspace/.devcontainer/config/claude/output-styles"
+    local styles_target_home="/home/node/.claude/output-styles"
+    local styles_target_workspace="/workspace/.claude/output-styles"
+    
+    if [ ! -d "$styles_source" ]; then
+        echo "📝 Output styles directory not found, skipping"
+        return 0
+    fi
+    
+    local copy_styles=false
+    if [ "${OVERRIDE_CLAUDE_OUTPUT_STYLES:-false}" = "true" ]; then
+        echo "📝 OVERRIDE_CLAUDE_OUTPUT_STYLES=true: Forcing overwrite of Claude output styles"
+        copy_styles=true
+    elif [ ! -d "$styles_target_home" ] && [ ! -d "$styles_target_workspace" ]; then
+        echo "📝 Creating Claude output styles (no existing directories found)"
+        copy_styles=true
+    else
+        echo "📁 Preserving existing Claude output styles (set OVERRIDE_CLAUDE_OUTPUT_STYLES=true to overwrite)"
+    fi
+    
+    if [ "$copy_styles" = "true" ]; then
+        # Create backups of existing output styles directories
+        if [ -d "$styles_target_home" ]; then
+            local backup_dir="/workspace/.devcontainer/config/backups"
+            mkdir -p "$backup_dir"
+            local timestamp=$(date +"%Y%m%d_%H%M%S")
+            local backup_home="${backup_dir}/home_node_.claude_output-styles.${timestamp}.backup"
+            cp -r "$styles_target_home" "$backup_home"
+            chown -R node:node "$backup_home"
+            chmod -R 600 "$backup_home"
+            echo "📦 Created backup: $backup_home"
+        fi
+        
+        if [ -d "$styles_target_workspace" ]; then
+            local backup_dir="/workspace/.devcontainer/config/backups"
+            mkdir -p "$backup_dir"
+            local timestamp=$(date +"%Y%m%d_%H%M%S")
+            local backup_workspace="${backup_dir}/workspace_.claude_output-styles.${timestamp}.backup"
+            cp -r "$styles_target_workspace" "$backup_workspace"
+            chown -R node:node "$backup_workspace"
+            chmod -R 600 "$backup_workspace"
+            echo "📦 Created backup: $backup_workspace"
+        fi
+        
+        # Copy to home directory (will be bind-mounted to workspace)
+        mkdir -p "$styles_target_home"
+        cp -r "$styles_source"/* "$styles_target_home"/
+        chown -R node:node "$styles_target_home"
+        chmod -R 600 "$styles_target_home"
+        
+        # Also copy directly to workspace for redundancy
+        mkdir -p "$styles_target_workspace"
+        cp -r "$styles_source"/* "$styles_target_workspace"/
+        chown -R node:node "$styles_target_workspace"
+        chmod -R 600 "$styles_target_workspace"
+        
+        echo "📋 Claude output styles configured"
+    fi
+}

package/.devcontainer/scripts/config/searxng.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+# SearXNG MCP Enhanced Configuration Module
+# Handles MCP SearXNG Enhanced installation and configuration setup
+
+install_searxng_mcp() {
+    echo "🔧 Installing MCP SearXNG Enhanced..."
+    
+    # Define installation paths
+    local mcp_install_dir="/usr/local/mcp-servers/searxng"
+    local temp_dir="/tmp/mcp-searxng-enhanced"
+    local repo_url="https://github.com/OvertliDS/mcp-searxng-enhanced"
+    
+    # Create installation directory
+    sudo mkdir -p "$mcp_install_dir"
+    
+    # Clone repository to temporary location
+    echo "📥 Cloning MCP SearXNG Enhanced repository..."
+    if [ -d "$temp_dir" ]; then
+        rm -rf "$temp_dir"
+    fi
+    
+    git clone "$repo_url" "$temp_dir" 2>/dev/null || {
+        echo "❌ Failed to clone repository from $repo_url"
+        return 1
+    }
+    
+    # Install Python dependencies using uv with the correct Python version
+    echo "📦 Installing Python dependencies..."
+    sudo /home/node/.local/bin/uv pip install --python /usr/local/python/current/bin/python3 --system -r "$temp_dir/requirements.txt" || {
+        echo "❌ Failed to install Python dependencies"
+        return 1
+    }
+    
+    # Copy MCP server files
+    echo "📋 Copying MCP server files..."
+    sudo cp "$temp_dir/mcp_server.py" "$mcp_install_dir/"
+    sudo chmod +x "$mcp_install_dir/mcp_server.py"
+    
+    # Copy additional files if they exist
+    if [ -f "$temp_dir/README.md" ]; then
+        sudo cp "$temp_dir/README.md" "$mcp_install_dir/"
+    fi
+    
+    # Clean up temporary directory
+    rm -rf "$temp_dir"
+    
+    echo "✅ MCP SearXNG Enhanced installed successfully"
+}
+
+setup_searxng_config() {
+    echo "🔧 Setting up SearXNG configuration..."
+    
+    local config_source="/workspace/.devcontainer/config/searxng/ods_config.json"
+    local config_target="/home/node/.claude/ods_config.json"
+    
+    if [ ! -f "$config_source" ]; then
+        echo "⚠️  SearXNG configuration template not found, using defaults"
+        return 1
+    fi
+    
+    # Ensure Claude directory exists
+    mkdir -p "/home/node/.claude"
+    
+    local copy_config=false
+    if [ "${OVERRIDE_SEARXNG_CONFIG:-false}" = "true" ]; then
+        echo "📝 OVERRIDE_SEARXNG_CONFIG=true: Forcing overwrite of SearXNG configuration"
+        copy_config=true
+    elif [ ! -f "$config_target" ]; then
+        echo "📝 Creating SearXNG configuration (no existing file found)"
+        copy_config=true
+    else
+        echo "📁 Preserving existing SearXNG configuration (set OVERRIDE_SEARXNG_CONFIG=true to overwrite)"
+    fi
+    
+    if [ "$copy_config" = "true" ]; then
+        # Copy configuration file
+        cp "$config_source" "$config_target"
+        chown node:node "$config_target"
+        chmod 600 "$config_target"
+        
+        echo "📋 Copied optimized SearXNG configuration"
+    fi
+    
+    echo "✅ SearXNG configuration ready"
+}
+
+validate_searxng_connection() {
+    echo "🔍 Validating SearXNG connection..."
+    
+    local searxng_url="${SEARXNG_ENGINE_API_BASE_URL:-http://localhost:8080/search}"
+    
+    # Test connection to SearXNG instance
+    if command -v curl >/dev/null 2>&1; then
+        if curl -s --connect-timeout 10 --max-time 30 "${searxng_url%/search}" >/dev/null; then
+            echo "✅ SearXNG instance at $searxng_url is accessible"
+            return 0
+        else
+            echo "⚠️  Warning: SearXNG instance at $searxng_url may not be accessible"
+            echo "   MCP server will still be configured but may fail during runtime"
+            return 1
+        fi
+    else
+        echo "⚠️  curl not found, skipping connection validation"
+        return 1
+    fi
+}
+
+setup_searxng_environment() {
+    echo "🌍 Setting up SearXNG environment variables..."
+    
+    # Set default environment variables if not already set
+    export ODS_CONFIG_PATH="${ODS_CONFIG_PATH:-/home/node/.claude/ods_config.json}"
+    export SEARXNG_ENGINE_API_BASE_URL="${SEARXNG_ENGINE_API_BASE_URL:-http://localhost:8080/search}"
+    export DESIRED_TIMEZONE="${DESIRED_TIMEZONE:-America/New_York}"
+    
+    echo "📋 Environment variables configured:"
+    echo "   ODS_CONFIG_PATH=$ODS_CONFIG_PATH"
+    echo "   SEARXNG_ENGINE_API_BASE_URL=$SEARXNG_ENGINE_API_BASE_URL"
+    echo "   DESIRED_TIMEZONE=$DESIRED_TIMEZONE"
+    
+    echo "✅ SearXNG environment ready"
+}
+
+# Main setup function
+setup_searxng() {
+    if [ "${ENABLE_SEARXNG_ENHANCED_MCP:-true}" != "true" ]; then
+        echo "⏭️  SearXNG Enhanced MCP is disabled (set ENABLE_SEARXNG_ENHANCED_MCP=true to enable)"
+        return 0
+    fi
+    
+    echo "🔄 Setting up MCP SearXNG Enhanced..."
+    
+    # Run installation and configuration steps
+    install_searxng_mcp || return 1
+    setup_searxng_config || return 1
+    setup_searxng_environment
+    validate_searxng_connection || echo "   (Connection validation failed, but continuing with setup)"
+    
+    echo "✅ MCP SearXNG Enhanced setup complete"
+    
+    return 0
+}

package/.devcontainer/scripts/config/serena.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+# Serena Configuration Module
+# Handles Serena MCP server configuration setup
+
+setup_serena_config() {
+    echo "🔧 Setting up Serena configuration..."
+    
+    local serena_source="/workspace/.devcontainer/config/serena/serena_config.yml"
+    local serena_target_home="/home/node/.serena/serena_config.yml"
+    local serena_target_workspace="/workspace/.serena/serena_config.yml"
+    
+    if [ ! -f "$serena_source" ]; then
+        echo "⚠️  Serena configuration template not found, using defaults"
+        return 1
+    fi
+    
+    # Ensure Serena directories exist
+    mkdir -p "/home/node/.serena" "/workspace/.serena"
+    
+    local copy_serena=false
+    if [ "${OVERRIDE_SERENA_CONFIG:-false}" = "true" ]; then
+        echo "📝 OVERRIDE_SERENA_CONFIG=true: Forcing overwrite of Serena configuration"
+        copy_serena=true
+    elif [ ! -f "$serena_target_home" ] && [ ! -f "$serena_target_workspace" ]; then
+        echo "📝 Creating Serena configuration (no existing files found)"
+        copy_serena=true
+    else
+        echo "📁 Preserving existing Serena configuration (set OVERRIDE_SERENA_CONFIG=true to overwrite)"
+    fi
+    
+    if [ "$copy_serena" = "true" ]; then
+        # Copy to home directory (will be bind-mounted to workspace)
+        cp "$serena_source" "$serena_target_home"
+        chown node:node "$serena_target_home"
+        chmod 600 "$serena_target_home"
+        
+        # Also copy directly to workspace for redundancy
+        cp "$serena_source" "$serena_target_workspace"
+        chown node:node "$serena_target_workspace"
+        chmod 600 "$serena_target_workspace"
+        
+        echo "📋 Copied optimized Serena configuration"
+    fi
+    
+    echo "✅ Serena configuration ready"
+}

package/.devcontainer/scripts/config/taskmaster.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# TaskMaster Configuration Module  
+# Handles TaskMaster AI configuration setup
+
+setup_taskmaster_config() {
+    echo "🔧 Setting up TaskMaster configuration..."
+    
+    local taskmaster_source="/workspace/.devcontainer/config/taskmaster/config.json"
+    local taskmaster_target_workspace="/workspace/.taskmaster/config.json"
+    
+    if [ ! -f "$taskmaster_source" ]; then
+        echo "⚠️  TaskMaster configuration template not found, using defaults"
+        return 1
+    fi
+    
+    # Ensure TaskMaster directory exists
+    mkdir -p "/workspace/.taskmaster"
+    
+    local copy_taskmaster=false
+    if [ "${OVERRIDE_TASKMASTER_CONFIG:-false}" = "true" ]; then
+        echo "📝 OVERRIDE_TASKMASTER_CONFIG=true: Forcing overwrite of TaskMaster configuration"
+        copy_taskmaster=true
+    elif [ ! -f "$taskmaster_target_workspace" ]; then
+        echo "📝 Creating TaskMaster configuration (no existing files found)"
+        copy_taskmaster=true
+    else
+        echo "📁 Preserving existing TaskMaster configuration (set OVERRIDE_TASKMASTER_CONFIG=true to overwrite)"
+    fi
+    
+    if [ "$copy_taskmaster" = "true" ]; then
+        # Copy to workspace
+        cp "$taskmaster_source" "$taskmaster_target_workspace"
+        chown node:node "$taskmaster_target_workspace"
+        chmod 600 "$taskmaster_target_workspace"
+        
+        echo "📋 Copied optimized TaskMaster configuration"
+    fi
+    
+    echo "✅ TaskMaster configuration ready"
+}

package/.devcontainer/scripts/generate-mcp-config.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * Generate MCP configuration from template based on environment variables
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Load environment variables from .env file (industry standard approach)
+const ENV_FILE_PATH = '/workspace/.devcontainer/.env';
+try {
+  require('dotenv').config({ path: ENV_FILE_PATH, override: true });
+  console.log(`[MCP Config Generator] Loaded environment from ${ENV_FILE_PATH}`);
+} catch (error) {
+  console.log(`[MCP Config Generator] dotenv not available, using process.env: ${error.message}`);
+}
+
+const CONFIG_DIR = '/workspace/.devcontainer/config/claude';
+const TEMPLATE_PATH = path.join(CONFIG_DIR, 'mcp.json.template');
+const OUTPUT_PATH = path.join(CONFIG_DIR, 'mcp.json');
+const BACKUP_PATH = path.join(CONFIG_DIR, 'mcp.json.backup');
+
+function log(message) {
+  console.log(`[MCP Config Generator] ${message}`);
+}
+
+function parseBoolean(value, defaultValue = false) {
+  if (!value) return defaultValue;
+  const lowerValue = value.toLowerCase().trim();
+  return lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes';
+}
+
+function expandEnvironmentVariables(text, env) {
+  return text.replace(/\$\{([^}:-]+)(:-([^}]*))?\}/g, (match, varName, _, defaultValue) => {
+    const envValue = env[varName];
+    if (envValue !== undefined) {
+      return envValue;
+    }
+    return defaultValue || '';
+  });
+}
+
+function hasRequiredApiKeys(requires, env) {
+  if (!requires || requires.length === 0) return true;
+  
+  return requires.every(key => {
+    const value = env[key];
+    return value && value.trim() !== '';
+  });
+}
+
+function validateMcpConfiguration(config) {
+  try {
+    // Validate top-level structure
+    if (!config || typeof config !== 'object') {
+      log('Validation Error: Configuration must be an object');
+      return false;
+    }
+    
+    if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+      log('Validation Error: Configuration must have mcpServers object');
+      return false;
+    }
+    
+    // Validate each server configuration
+    for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+      if (!validateServerConfig(serverName, serverConfig)) {
+        return false;
+      }
+    }
+    
+    log('MCP configuration validation passed');
+    return true;
+  } catch (error) {
+    log(`Validation Error: ${error.message}`);
+    return false;
+  }
+}
+
+function validateServerConfig(serverName, config) {
+  // Check for required fields based on server type
+  if (config.command) {
+    // Command-based server
+    if (!Array.isArray(config.args)) {
+      log(`Validation Error: Server ${serverName} with command must have args array`);
+      return false;
+    }
+  } else if (config.type === 'http') {
+    // HTTP-based server
+    if (!config.url || typeof config.url !== 'string') {
+      log(`Validation Error: HTTP server ${serverName} must have valid url`);
+      return false;
+    }
+    
+    // Validate URL format
+    try {
+      new URL(config.url);
+    } catch (urlError) {
+      log(`Validation Error: Server ${serverName} has invalid URL: ${config.url}`);
+      return false;
+    }
+  } else {
+    log(`Validation Error: Server ${serverName} must have either 'command' or 'type' field`);
+    return false;
+  }
+  
+  return true;
+}
+
+function generateMcpConfig() {
+  try {
+    // Check if template exists
+    if (!fs.existsSync(TEMPLATE_PATH)) {
+      log(`Template file not found: ${TEMPLATE_PATH}`);
+      return false;
+    }
+
+    // Read template
+    const templateContent = fs.readFileSync(TEMPLATE_PATH, 'utf8');
+    let templateData;
+    
+    try {
+      // First expand environment variables in the template
+      const expandedTemplate = expandEnvironmentVariables(templateContent, process.env);
+      templateData = JSON.parse(expandedTemplate);
+    } catch (error) {
+      log(`Failed to parse template: ${error.message}`);
+      return false;
+    }
+
+    // Create backup of existing config if it exists
+    if (fs.existsSync(OUTPUT_PATH)) {
+      fs.copyFileSync(OUTPUT_PATH, BACKUP_PATH);
+      log(`Created backup: ${BACKUP_PATH}`);
+    }
+
+    // Generate output configuration
+    const outputConfig = {
+      mcpServers: {}
+    };
+
+    let enabledCount = 0;
+    let disabledCount = 0;
+
+    // Process each server
+    for (const [serverName, serverData] of Object.entries(templateData.servers)) {
+      const enabled = parseBoolean(serverData.enabled, false);
+      const hasApiKeys = hasRequiredApiKeys(serverData.requires, process.env);
+      
+      if (enabled && hasApiKeys) {
+        // Server is enabled and has required API keys
+        // Flatten the config structure - remove the nested "config" wrapper
+        outputConfig.mcpServers[serverName] = serverData.config;
+        enabledCount++;
+        log(`✓ Enabled: ${serverName}`);
+      } else {
+        // Server is disabled or missing API keys
+        disabledCount++;
+        if (!enabled) {
+          log(`✗ Disabled: ${serverName} (ENABLE_${serverName.toUpperCase().replace(/-/g, '_')}_MCP=false)`);
+        } else {
+          log(`✗ Disabled: ${serverName} (missing required API keys: ${serverData.requires?.join(', ')})`);
+        }
+      }
+    }
+
+    // Keep environment variables as references, don't expand them
+    const finalConfigText = JSON.stringify(outputConfig, null, 2);
+    
+    // Write output
+    fs.writeFileSync(OUTPUT_PATH, finalConfigText);
+    
+    // Basic validation - ensure output is valid JSON
+    try {
+      JSON.parse(finalConfigText);
+    } catch (parseError) {
+      log(`Error: Generated configuration is not valid JSON: ${parseError.message}`);
+      return false;
+    }
+    
+    // Advanced validation - validate MCP configuration structure
+    if (!validateMcpConfiguration(outputConfig)) {
+      log(`Error: Generated MCP configuration failed validation`);
+      return false;
+    }
+    
+    log(`Configuration generated successfully!`);
+    log(`Servers enabled: ${enabledCount}, disabled: ${disabledCount}`);
+    log(`Output: ${OUTPUT_PATH}`);
+    
+    return true;
+    
+  } catch (error) {
+    log(`Error generating configuration: ${error.message}`);
+    return false;
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const success = generateMcpConfig();
+  process.exit(success ? 0 : 1);
+}
+
+module.exports = { generateMcpConfig };