Complete feature: mcpd config export (#106)

* Complete export functionality for mcpd config

Completes the partially implemented 'mcpd config export' command by adding
support for config file processing alongside the existing runtime file handling.

The export now generates two output files:
1. Portable execution context (secrets.prod.toml) with templated variable references
2. Environment contract (.env) with placeholder mappings for CI/CD systems

Key improvements:
- Processes both config and runtime files (was runtime-only before)
- Supports all server configuration types (env vars, args, bool args)
- Generates consistent placeholder naming: MCPD__{SERVER_NAME}__{VAR_NAME}
- Handles server names with hyphens (converts to underscores in placeholders)
- Validates required configuration fields
- Provides clear success/error messaging

Fixes the bug where only runtime configuration was being exported.

* Add comprehensive testdata for export command testing

Adds structured testdata files for testing export functionality across
different server configurations:

- basic_export: Server with all config types (env, args, bool args)
- multiple_servers: Multiple servers with different requirements
- github_server_hyphens: Server name with hyphens (tests name conversion)
- minimal_server_required_only: Server with required fields only

Each testdata directory contains:
- config.test.toml: Input server configuration
- secrets.test.toml: Input runtime secrets
- context.test.toml: Expected portable execution context output
- contract.test.env: Expected environment contract output

These files enable comprehensive integration testing of the export
functionality without relying on inline test data.

* Fix export bugs and add comprehensive testing

Fixes critical bugs discovered during manual testing:

1. Missing required config fields in AggregateConfigs function
   - Added RequiredEnvVars, RequiredValueArgs, RequiredBoolArgs copying

2. Missing environment variables in contract file output
   - Created envVarsToContract helper function
   - Added proper environment variable placeholder extraction

3. Inconsistent .env file ordering
   - Fixed lexicographical sorting using slices.Sort

4. Empty placeholder validation issues
   - Added strings.TrimSpace and empty string filtering

Additional improvements:
- Added comprehensive unit tests for envVarsToContract function
- Enhanced error handling and validation
- Improved placeholder name consistency across all output formats

These fixes ensure the export functionality works correctly for all
supported configuration scenarios.

* Add comprehensive test suite for export command

Implements a full test suite for the export functionality with:

Integration Tests:
- Tests all server configuration scenarios using testdata files
- Verifies both context and contract output file generation
- Covers edge cases like server names with hyphens
- Tests required-only configurations (no runtime secrets)

Error Tests:
- Tests malformed configuration files
- Tests missing server configurations
- Verifies proper error messages and no output file creation

Unit Tests:
- Tests dotenv file writing with various data scenarios
- Tests lexicographical sorting and newline escaping

Test Infrastructure:
- dataPathsForTest: Helper for consistent testdata file path management
- overrideFlagsForTest: Helper for clean global flag override with automatic cleanup
- Comprehensive constants for test file naming consistency
- Proper use of t.Helper() and t.Cleanup() patterns

Author: peteski22

cmd/config/export/export.go

@@ -2,6 +2,9 @@ package export
 
 import (
 	"fmt"
+	"os"
+	"slices"
+	"strings"
 
 	"github.com/spf13/cobra"
 
@@ -10,6 +13,7 @@ import (
 	"github.com/mozilla-ai/mcpd/v2/internal/config"
 	"github.com/mozilla-ai/mcpd/v2/internal/context"
 	"github.com/mozilla-ai/mcpd/v2/internal/flags"
+	"github.com/mozilla-ai/mcpd/v2/internal/runtime"
 )
 
 type Cmd struct {
@@ -82,44 +86,60 @@ func (c *Cmd) longDescription() string {
 }
 
 func (c *Cmd) run(cmd *cobra.Command, _ []string) error {
-	contextPath := c.ContextOutput
-	// contractPath := c.ContractOutput
-
-	if err := exportPortableExecutionContext(c.ctxLoader, flags.RuntimeFile, contextPath); err != nil {
+	if err := c.handleExport(); err != nil {
 		return err
 	}
 
-	if _, err := fmt.Fprintf(
-		cmd.OutOrStdout(),
-		"✓ Portable Execution Context exported: %s\n", contextPath,
-	); err != nil {
-		return err
+	_, _ = fmt.Fprintf(cmd.OutOrStdout(), "✓ Environment Contract exported: %s\n", c.ContractOutput)
+	_, _ = fmt.Fprintf(cmd.OutOrStdout(), "✓ Portable Execution Context exported: %s\n", c.ContextOutput)
+	_, _ = fmt.Fprintf(cmd.OutOrStdout(), "✓ Export completed successfully!\n")
+
+	return nil
+}
+
+func (c *Cmd) handleExport() error {
+	cfg, err := c.cfgLoader.Load(flags.ConfigFile)
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	rtCtx, err := c.ctxLoader.Load(flags.RuntimeFile)
+	if err != nil {
+		return fmt.Errorf("failed to load execution context config: %w", err)
 	}
 
-	// Export 'Environment Contract'
-	// TODO: export to contractPath based on format
-	// fmt.Fprintf(cmd.OutOrStdout(), "✓ Environment Contract exported: %s\n", contractPath)
+	servers, err := runtime.AggregateConfigs(cfg, rtCtx)
+	if err != nil {
+		return err
+	}
 
-	if _, err := fmt.Fprintf(
-		cmd.OutOrStdout(),
-		"✓ Export completed successfully!\n",
-	); err != nil {
+	contract, err := servers.Export(c.ContextOutput)
+	if err != nil {
 		return err
 	}
 
-	return nil
+	// TODO: Support other 'c.Format's
+	return writeDotenvFile(c.ContractOutput, contract)
 }
 
-func exportPortableExecutionContext(loader context.Loader, src string, dest string) error {
-	mod, err := loader.Load(src)
-	if err != nil {
-		return fmt.Errorf("failed to load execution context config: %w", err)
-	}
+func writeDotenvFile(path string, data map[string]string) error {
+	var b strings.Builder
 
-	exp, ok := mod.(context.Exporter)
-	if !ok {
-		return fmt.Errorf("execution context config does not support exporting")
+	// Get keys and sort them lexicographically
+	keys := make([]string, 0, len(data))
+	for k := range data {
+		keys = append(keys, k)
+	}
+	slices.Sort(keys)
+
+	// Write entries in sorted order
+	for _, k := range keys {
+		v := data[k]
+		escaped := strings.ReplaceAll(v, "\n", "\\n")
+		if _, err := fmt.Fprintf(&b, "%s=%s\n", k, escaped); err != nil {
+			return err
+		}
 	}
 
-	return exp.Export(dest)
+	return os.WriteFile(path, []byte(b.String()), 0o644)
 }