feat: add mcpd config volumes set command (#244)

* feat: add mcpd config volumes set command

Add CLI command to set host paths for Docker volume mappings on MCP
servers. Volumes are stored in the runtime execution context config
file and can be referenced by server configurations.

Usage: mcpd config volumes set <server> -- --<volume>=<path>

Closes #197

* fix: use RawVolumes to avoid persisting expanded env vars in volumes set

When Load() reads the TOML config, it expands environment variables
into server.Volumes and preserves the originals in server.RawVolumes.
The set command was updating server.Volumes (already expanded) and
persisting those back to disk, which would destroy ${MCPD__...}
placeholders needed for cross-server reference filtering.

Use RawVolumes as the source of truth when updating volume mappings
so unexpanded values are preserved on disk.

* fix: clone RawVolumes into Volumes to prevent map aliasing

Address review feedback: use maps.Clone when syncing Volumes from
RawVolumes to decouple the two maps. Also tighten the "add multiple
volumes" test to assert exact sorted output and verify RawVolumes
alongside Volumes on upsert.

* fix: initialise RawVolumes from Volumes when nil to preserve existing mappings

When RawVolumes is nil (e.g. from a loader that doesn't populate it),
fall back to cloning Volumes so existing volume mappings are not lost
when adding new ones. Adds a test case covering this scenario.

* fix: clone volume maps before mutation to avoid corrupting config state

Maps are reference types in Go, so mutating server.RawVolumes via
maps.Copy directly modifies the config's internal state before Upsert
is called. If Upsert fails, the in-memory config is silently corrupted.

Clone into a working map before applying changes, then assign back.

Author: peteski22

cmd/config/config.go

@@ -9,6 +9,7 @@ import (
 	"github.com/mozilla-ai/mcpd/cmd/config/export"
 	"github.com/mozilla-ai/mcpd/cmd/config/plugins"
 	"github.com/mozilla-ai/mcpd/cmd/config/tools"
+	"github.com/mozilla-ai/mcpd/cmd/config/volumes"
 	"github.com/mozilla-ai/mcpd/internal/cmd"
 	"github.com/mozilla-ai/mcpd/internal/cmd/options"
 )
@@ -27,6 +28,7 @@ func NewConfigCmd(baseCmd *cmd.BaseCmd, opt ...options.CmdOption) (*cobra.Comman
 		env.NewCmd,     // env
 		plugins.NewCmd, // plugins
 		tools.NewCmd,   // tools
+		volumes.NewCmd, // volumes
 		export.NewCmd,  // export
 	}
 

cmd/config/volumes/cmd.go

@@ -0,0 +1,33 @@
+package volumes
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/mozilla-ai/mcpd/internal/cmd"
+	cmdopts "github.com/mozilla-ai/mcpd/internal/cmd/options"
+)
+
+// NewCmd creates a new volumes command with its sub-commands.
+func NewCmd(baseCmd *cmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command, error) {
+	cobraCmd := &cobra.Command{
+		Use:   "volumes",
+		Short: "Manages volume configuration for MCP servers",
+		Long: "Manages Docker volume configuration for MCP servers, " +
+			"dealing with setting, removing, clearing and listing volume mappings.",
+	}
+
+	// Sub-commands for: mcpd config volumes
+	fns := []func(baseCmd *cmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command, error){
+		NewSetCmd, // set
+	}
+
+	for _, fn := range fns {
+		tempCmd, err := fn(baseCmd, opt...)
+		if err != nil {
+			return nil, err
+		}
+		cobraCmd.AddCommand(tempCmd)
+	}
+
+	return cobraCmd, nil
+}

cmd/config/volumes/set.go

@@ -0,0 +1,196 @@
+package volumes
+
+import (
+	"fmt"
+	"maps"
+	"slices"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/mozilla-ai/mcpd/internal/cmd"
+	cmdopts "github.com/mozilla-ai/mcpd/internal/cmd/options"
+	"github.com/mozilla-ai/mcpd/internal/context"
+	"github.com/mozilla-ai/mcpd/internal/flags"
+)
+
+// setCmd handles setting volume mappings for MCP servers.
+type setCmd struct {
+	*cmd.BaseCmd
+	ctxLoader context.Loader
+}
+
+// NewSetCmd creates a new set command for volume configuration.
+func NewSetCmd(baseCmd *cmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command, error) {
+	opts, err := cmdopts.NewOptions(opt...)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &setCmd{
+		BaseCmd:   baseCmd,
+		ctxLoader: opts.ContextLoader,
+	}
+
+	cobraCmd := &cobra.Command{
+		Use:   "set <server-name> -- --<volume-name>=<host-path> [--<volume-name>=<host-path>...]",
+		Short: "Set or update volume mappings for an MCP server",
+		Long: "Set volume mappings for an MCP server in the runtime context " +
+			"configuration file (e.g. " + flags.RuntimeFile + ").\n\n" +
+			"Volume mappings associate volume names with host paths or named Docker volumes.\n" +
+			"Use -- to separate the server name from the volume mappings.\n\n" +
+			"Examples:\n" +
+			"  # Set a single volume mapping\n" +
+			"  mcpd config volumes set filesystem -- --workspace=/Users/foo/repos/mcpd\n\n" +
+			"  # Set multiple volume mappings\n" +
+			"  mcpd config volumes set filesystem -- --workspace=\"/Users/foo/repos\" --gdrive=\"/mcp/gdrive\"\n\n" +
+			"  # Use a named Docker volume\n" +
+			"  mcpd config volumes set myserver -- --data=my-named-volume",
+		RunE: c.run,
+		Args: validateSetArgs,
+	}
+
+	return cobraCmd, nil
+}
+
+// validateSetArgs validates the arguments for the set command.
+// It wraps validateArgs to extract the dash position from the cobra command.
+func validateSetArgs(cmd *cobra.Command, args []string) error {
+	return validateArgs(cmd.ArgsLenAtDash(), args)
+}
+
+// validateArgs validates the set command arguments given the dash position and args slice.
+func validateArgs(dashPos int, args []string) error {
+	// No args at all.
+	if len(args) == 0 {
+		return fmt.Errorf("server-name is required")
+	}
+	// Args provided but no -- separator (user forgot --).
+	if dashPos == -1 {
+		return fmt.Errorf(
+			"missing '--' separator: usage: mcpd config volumes set <server-name> -- --<volume>=<path>",
+		)
+	}
+	// -- at position 0 (no server name before it) or server name is empty.
+	if dashPos < 1 || strings.TrimSpace(args[0]) == "" {
+		return fmt.Errorf("server-name is required")
+	}
+	if dashPos > 1 {
+		return fmt.Errorf("too many arguments before --")
+	}
+	if len(args) < 2 {
+		return fmt.Errorf("volume mapping(s) required after --")
+	}
+	return nil
+}
+
+// run executes the set command, parsing volume mappings and updating the server config.
+func (c *setCmd) run(cmd *cobra.Command, args []string) error {
+	serverName := strings.TrimSpace(args[0])
+
+	// volumeArgs contains everything after the -- separator.
+	// validateSetArgs guarantees len(args) >= 2.
+	volumeArgs := args[1:]
+	volumeMap, err := parseVolumeArgs(volumeArgs)
+	if err != nil {
+		return err
+	}
+
+	cfg, err := c.ctxLoader.Load(flags.RuntimeFile)
+	if err != nil {
+		return fmt.Errorf("failed to load execution context config: %w", err)
+	}
+
+	server, exists := cfg.Get(serverName)
+	if !exists {
+		server.Name = serverName
+	}
+
+	// Clone into a working map to avoid mutating the config's internal state.
+	// Use RawVolumes as the source of truth to avoid persisting expanded
+	// environment variables (e.g. ${MCPD__...} placeholders) back to disk.
+	// Fall back to Volumes if RawVolumes is nil to preserve existing mappings.
+	working := maps.Clone(server.RawVolumes)
+	if working == nil {
+		working = maps.Clone(server.Volumes)
+	}
+	if working == nil {
+		working = context.VolumeExecutionContext{}
+	}
+
+	maps.Copy(working, volumeMap)
+
+	// Assign the working map back so Upsert persists unexpanded values.
+	// RawVolumes is the single source of truth; Volumes is derived.
+	server.RawVolumes = working
+	server.Volumes = maps.Clone(working)
+
+	res, err := cfg.Upsert(server)
+	if err != nil {
+		return fmt.Errorf("error setting volumes for server '%s': %w", serverName, err)
+	}
+
+	volumeNames := slices.Collect(maps.Keys(volumeMap))
+	slices.Sort(volumeNames)
+	if _, err := fmt.Fprintf(
+		cmd.OutOrStdout(),
+		"✓ Volumes set for server '%s' (operation: %s): %v\n", serverName, string(res), volumeNames,
+	); err != nil {
+		return fmt.Errorf("failed to write output: %w", err)
+	}
+
+	return nil
+}
+
+// parseVolumeArgs parses volume arguments in the format --name=path or --name="path".
+func parseVolumeArgs(args []string) (map[string]string, error) {
+	volumes := make(map[string]string, len(args))
+
+	for _, arg := range args {
+		originalArg := arg
+
+		// Expect format: --name=path
+		if !strings.HasPrefix(arg, "--") {
+			return nil, fmt.Errorf("invalid volume format '%s': must start with --", arg)
+		}
+
+		// Remove the -- prefix for parsing.
+		arg = strings.TrimPrefix(arg, "--")
+
+		parts := strings.SplitN(arg, "=", 2)
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("invalid volume format '%s': expected --<volume-name>=<host-path>", originalArg)
+		}
+
+		name := strings.TrimSpace(parts[0])
+		path := strings.TrimSpace(parts[1])
+
+		if name == "" {
+			return nil, fmt.Errorf("volume name cannot be empty in '%s'", originalArg)
+		}
+
+		if path == "" {
+			return nil, fmt.Errorf("volume path cannot be empty for volume '%s'", name)
+		}
+
+		// Remove surrounding quotes if present.
+		path = trimQuotes(path)
+		if path == "" {
+			return nil, fmt.Errorf("volume path cannot be empty for volume '%s'", name)
+		}
+
+		volumes[name] = path
+	}
+
+	return volumes, nil
+}
+
+// trimQuotes removes surrounding single or double quotes from a string.
+func trimQuotes(s string) string {
+	if len(s) >= 2 {
+		if (s[0] == '"' && s[len(s)-1] == '"') || (s[0] == '\'' && s[len(s)-1] == '\'') {
+			return s[1 : len(s)-1]
+		}
+	}
+	return s
+}