Update Models

* Drop args/env from Package.Installations
* Drop args.env from Mozilla-ai's Server.Installations
* Drop args/env from MCPM registry server installations
* Update tests

Author: peteski22

internal/packages/installation.go

@@ -5,15 +5,13 @@ import "github.com/mozilla-ai/mcpd/v2/internal/runtime"
 type Installations map[runtime.Runtime]Installation
 
 type Installation struct {
-	Command     string            `json:"command"`
-	Args        []string          `json:"args"`
-	Package     string            `json:"package,omitempty"`
-	Version     string            `json:"version,omitempty"`
-	Env         map[string]string `json:"env,omitempty"`
-	Description string            `json:"description,omitempty"`
-	Recommended bool              `json:"recommended,omitempty"`
-	Deprecated  bool              `json:"deprecated,omitempty"`
-	Transports  []Transport       `json:"transports,omitempty"`
+	Command     string      `json:"command"`
+	Package     string      `json:"package,omitempty"`
+	Version     string      `json:"version,omitempty"`
+	Description string      `json:"description,omitempty"`
+	Recommended bool        `json:"recommended,omitempty"`
+	Deprecated  bool        `json:"deprecated,omitempty"`
+	Transports  []Transport `json:"transports,omitempty"`
 }
 
 // AnyDeprecated can be used to determine if any of the installations are deprecated.

internal/provider/mcpm/registry.go

@@ -423,9 +423,7 @@ func convertInstallations(
 
 		details[rt] = packages.Installation{
 			Command:     install.Command,
-			Args:        slices.Clone(install.Args),
 			Package:     pkg,
-			Env:         maps.Clone(install.Env),
 			Description: install.Description,
 			Recommended: install.Recommended,
 			Deprecated:  false,                        // MCPM doesn't support deprecated installations

internal/provider/mozilla_ai/model.go

@@ -81,18 +81,12 @@ type Installation struct {
 	// Runtime specifies the runtime type for this installation method.
 	Runtime Runtime `json:"runtime"`
 
-	// Args contains command-line arguments for the server.
-	Args []string `json:"args,omitempty"`
-
-	// Package is the package name for package manager installations.
+	// Package is the package name that will be executed.
 	Package string `json:"package,omitempty"`
 
 	// Version specifies the version for this installation method.
 	Version string `json:"version"`
 
-	// Env defines environment variables required for the server.
-	Env map[string]string `json:"env,omitempty"`
-
 	// Description provides additional details about this installation method.
 	Description string `json:"description,omitempty"`
 

internal/provider/mozilla_ai/registry.go

@@ -211,16 +211,6 @@ func (r *Registry) buildPackageResult(pkgKey string) (packages.Package, bool) {
 		return packages.Package{}, false
 	}
 
-	runtimesAndPackages, err := r.supportedRuntimePackageNames(sd.Installations)
-	if err != nil || len(runtimesAndPackages) == 0 {
-		r.logger.Debug(
-			"no supported runtime packages found in registry",
-			"pkgKey", pkgKey,
-			"error", err,
-		)
-		return packages.Package{}, false
-	}
-
 	tools, err := sd.Tools.ToDomainType()
 	if err != nil {
 		r.logger.Error(
@@ -270,37 +260,6 @@ func (r *Registry) buildPackageResult(pkgKey string) (packages.Package, bool) {
 	}, true
 }
 
-// supportedRuntimePackageNames extracts runtime-specific package names for a given MCP server.
-func (r *Registry) supportedRuntimePackageNames(
-	installations map[string]Installation,
-) (map[runtime.Runtime]string, error) {
-	result := make(map[runtime.Runtime]string)
-
-	specs := runtime.Specs()
-
-	for _, inst := range installations {
-		rt := runtime.Runtime(inst.Runtime)
-		if _, ok := r.supportedRuntimes[rt]; !ok {
-			continue
-		}
-
-		spec, ok := specs[rt]
-		if !ok || spec.ExtractPackageName == nil {
-			r.logger.Debug("no package extractor for runtime", "runtime", rt)
-			continue
-		}
-
-		pkg, err := spec.ExtractPackageName(inst.Args)
-		if err != nil {
-			return nil, fmt.Errorf("failed to extract package for runtime %q: %w", rt, err)
-		}
-
-		result[rt] = pkg
-	}
-
-	return result, nil
-}
-
 func convertInstallations(
 	src map[string]Installation,
 	supported map[runtime.Runtime]struct{},
@@ -309,7 +268,6 @@ func convertInstallations(
 		return nil
 	}
 
-	specs := runtime.Specs()
 	details := make(packages.Installations, len(src))
 
 	for _, install := range src {
@@ -318,23 +276,14 @@ func convertInstallations(
 			continue
 		}
 
-		pkg := ""
-		if spec, ok := specs[rt]; ok && spec.ExtractPackageName != nil {
-			if packageName, err := spec.ExtractPackageName(install.Args); err == nil {
-				pkg = packageName
-			}
-		}
-
 		details[rt] = packages.Installation{
 			Command:     string(install.Runtime),
-			Args:        slices.Clone(install.Args),
-			Package:     pkg,
+			Package:     install.Package,
 			Version:     install.Version,
-			Env:         maps.Clone(install.Env),
 			Description: install.Description,
 			Recommended: install.Recommended,
 			Deprecated:  install.Deprecated,
-			Transports:  packages.DefaultTransports(), // mozilla-ai defaults to stdio, could be extended per-installation later
+			Transports:  packages.DefaultTransports(), // TODO: mozilla-ai defaults to stdio, could be extended per-installation later
 		}
 	}
 

internal/provider/mozilla_ai/registry_test.go

@@ -42,32 +42,6 @@ func newTestLogger(t *testing.T) hclog.Logger {
 	})
 }
 
-// extractTestEnvVarNames extracts environment variable names from Arguments for testing.
-func extractTestEnvVarNames(t *testing.T, args packages.Arguments) []string {
-	t.Helper()
-
-	var envVars []string
-	for key, arg := range args {
-		if arg.VariableType == packages.VariableTypeEnv {
-			envVars = append(envVars, key)
-		}
-	}
-	return envVars
-}
-
-// extractTestCLIArgNames extracts CLI argument names from Arguments for testing.
-func extractTestCLIArgNames(t *testing.T, args packages.Arguments) []string {
-	t.Helper()
-
-	var cliArgs []string
-	for key, arg := range args {
-		if arg.VariableType == packages.VariableTypeArg || arg.VariableType == packages.VariableTypeArgBool {
-			cliArgs = append(cliArgs, key)
-		}
-	}
-	return cliArgs
-}
-
 func TestRegistry_ID(t *testing.T) {
 	t.Parallel()
 
@@ -456,69 +430,64 @@ func TestRegistry_Arguments_ToDomainType_EdgeCases(t *testing.T) {
 }
 
 func TestRegistry_Arguments_ToDomainType_WithTestdata(t *testing.T) {
+	t.Parallel()
+
 	testCases := []struct {
 		name         string
 		testdataFile string
 		serverName   string
-		description  string
 		expectedEnv  []string
 		expectedArgs []string
 	}{
 		{
 			name:         "environment variables only",
 			testdataFile: "arg_test_env_only.json",
 			serverName:   "env-only-server",
-			description:  "Server using only environment variables should extract env vars correctly",
 			expectedEnv:  []string{"API_KEY", "DEBUG_MODE"},
-			expectedArgs: []string{},
 		},
 		{
 			name:         "command-line arguments only",
 			testdataFile: "arg_test_cli_only.json",
 			serverName:   "cli-only-server",
-			description:  "Server using only CLI arguments should extract args correctly",
-			expectedEnv:  []string{},
-			expectedArgs: []string{"OUTPUT_FORMAT", "PORT", "ENABLE_CORS"},
+			expectedArgs: []string{"--output-format", "--port", "--enable-cors"},
 		},
 		{
 			name:         "mixed environment and arguments",
 			testdataFile: "arg_test_mixed_args.json",
 			serverName:   "mixed-args-server",
-			description:  "Server with mixed argument types should classify each correctly",
 			expectedEnv:  []string{"DATABASE_URL"},
-			expectedArgs: []string{"CONFIG_PATH", "VERBOSE"},
+			expectedArgs: []string{"--config-path", "--verbose"},
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			t.Logf("Test description: %s", tc.description)
+			t.Parallel()
 
-			// Load testdata registry
 			registry := loadTestDataRegistry(t, tc.testdataFile)
-
-			// Get the specific server we're testing
 			server, exists := registry[tc.serverName]
-			require.True(t, exists, "Server %q not found in testdata file %q", tc.serverName, tc.testdataFile)
+			require.True(t, exists)
 
-			// Convert arguments using Mozilla AI's ToDomainType method
 			result, err := server.Arguments.ToDomainType()
-			require.NoError(t, err, "Should convert arguments successfully")
+			require.NoError(t, err)
 
 			// Verify expected environment variables
-			envVars := extractTestEnvVarNames(t, result)
-			require.ElementsMatch(t, tc.expectedEnv, envVars,
-				"Unexpected environment variables for %s", tc.serverName)
+			envVars := result.FilterBy(packages.EnvVar).Names()
+			require.ElementsMatch(t, tc.expectedEnv, envVars)
+			for _, key := range tc.expectedEnv {
+				require.Equal(t, key, result[key].Name)
+			}
 
 			// Verify expected CLI arguments
-			cliArgs := extractTestCLIArgNames(t, result)
-			require.ElementsMatch(t, tc.expectedArgs, cliArgs,
-				"Unexpected CLI arguments for %s", tc.serverName)
+			cliArgs := result.FilterBy(packages.Argument).Names()
+			require.ElementsMatch(t, tc.expectedArgs, cliArgs)
+			for _, key := range tc.expectedArgs {
+				require.Equal(t, key, result[key].Name)
+			}
 
 			// Verify argument count matches expectations
 			expectedTotal := len(tc.expectedEnv) + len(tc.expectedArgs)
-			require.Len(t, result, expectedTotal,
-				"Total argument count mismatch for %s", tc.serverName)
+			require.Len(t, result, expectedTotal)
 		})
 	}
 }
@@ -559,8 +528,7 @@ func TestRegistry_BuildPackageResult_ArgumentExtraction(t *testing.T) {
 			Installations: map[string]Installation{
 				"npx": {
 					Runtime:     NPX,
-					Args:        []string{"test-server", "--config", "${CONFIG_FILE}", "--debug"},
-					Env:         map[string]string{"API_TOKEN": "${API_TOKEN}"},
+					Package:     "test-server",
 					Version:     "1.0.0",
 					Description: "Run with npx",
 					Recommended: true,
@@ -595,11 +563,11 @@ func TestRegistry_BuildPackageResult_ArgumentExtraction(t *testing.T) {
 	require.Len(t, pkg.Arguments, 3, "Should have 3 arguments")
 
 	// Check environment variable
-	envVars := extractTestEnvVarNames(t, pkg.Arguments)
+	envVars := pkg.Arguments.FilterBy(packages.EnvVar).Names()
 	require.ElementsMatch(t, []string{"API_TOKEN"}, envVars, "Should extract environment variable")
 
 	// Check CLI arguments
-	cliArgs := extractTestCLIArgNames(t, pkg.Arguments)
+	cliArgs := pkg.Arguments.FilterBy(packages.Argument).Names()
 	require.ElementsMatch(t, []string{"CONFIG_FILE", "DEBUG"}, cliArgs, "Should extract CLI arguments")
 
 	// Verify argument details
@@ -626,3 +594,74 @@ func TestRegistry_BuildPackageResult_ArgumentExtraction(t *testing.T) {
 	require.False(t, debug.Required)
 	require.Equal(t, "Enable debug mode", debug.Description)
 }
+
+func TestRegistry_BuildPackageResult_WithOptionalArguments(t *testing.T) {
+	t.Parallel()
+
+	testRegistry := loadTestDataRegistry(t, "registry_optional_args.json")
+
+	tests := []struct {
+		name      string
+		serverID  string
+		checkFunc func(t *testing.T, pkg packages.Package)
+	}{
+		{
+			name:     "time server with optional timezone argument",
+			serverID: "time",
+			checkFunc: func(t *testing.T, pkg packages.Package) {
+				require.Equal(t, "time", pkg.Name)
+				require.Equal(t, "Time Server", pkg.DisplayName)
+
+				// Check optional argument
+				tzArg, exists := pkg.Arguments["--local-timezone"]
+				require.True(t, exists)
+				require.False(t, tzArg.Required)
+				require.Equal(t, packages.VariableType("argument"), tzArg.VariableType)
+				require.Equal(t, "America/New_York", tzArg.Example)
+
+				// Check installation
+				uvxInstall, exists := pkg.Installations[runtime.UVX]
+				require.True(t, exists, "Should have UVX installation")
+				require.Equal(t, "mcp-server-time", uvxInstall.Package)
+			},
+		},
+		{
+			name:     "sqlite with required argument and package field",
+			serverID: "sqlite-with-package",
+			checkFunc: func(t *testing.T, pkg packages.Package) {
+				require.Equal(t, "sqlite-with-package", pkg.Name)
+
+				// Check required argument
+				dbArg, exists := pkg.Arguments["--db-path"]
+				require.True(t, exists)
+				require.True(t, dbArg.Required)
+
+				// Check installation with package field
+				uvxInstall, exists := pkg.Installations[runtime.UVX]
+				require.True(t, exists, "Should have UVX installation")
+				require.Equal(t, "mcp-server-sqlite", uvxInstall.Package)
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			logger := newTestLogger(t)
+			registry := &Registry{
+				mcpServers: testRegistry,
+				logger:     logger,
+				supportedRuntimes: map[runtime.Runtime]struct{}{
+					runtime.UVX: {},
+					runtime.NPX: {},
+				},
+				filterOptions: []options.Option{},
+			}
+
+			pkg, ok := registry.buildPackageResult(tc.serverID)
+			require.True(t, ok, "Should successfully build package result")
+			tc.checkFunc(t, pkg)
+		})
+	}
+}